@overdeck/desktop 0.49.1 → 0.50.0

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/20_testing.ts

@@ -0,0 +1,100 @@
+/**
+ * @title Testing HttpApi implementations
+ *
+ * Test handlers through an in-memory typed client with `HttpApiTest`, without
+ * starting an HTTP server or touching a real database.
+ */
+import { assert, layer } from "@effect/vitest"
+import { Effect, Layer } from "effect"
+import { HttpClientRequest, HttpServer } from "effect/unstable/http"
+import { HttpApiMiddleware, HttpApiTest } from "effect/unstable/httpapi"
+import { Api } from "./fixtures/api/Api.ts"
+import { Authorization } from "./fixtures/api/Authorization.ts"
+import { UserId } from "./fixtures/domain/User.ts"
+import { AuthorizationLayer } from "./fixtures/server/Authorization.ts"
+import { Users } from "./fixtures/server/Users.ts"
+import { UsersApiHandlersNoDeps } from "./fixtures/server/Users/http.ts"
+
+// Provide the handlers with the in-memory `Users` implementation, so the full
+// HTTP pipeline is exercised without any SQL. The Authorization middleware is
+// provided with `Layer.provideMerge`, because the HTTP pipeline also resolves
+// it when the routes are built.
+const HandlersLayer = UsersApiHandlersNoDeps.pipe(
+  Layer.provide(Users.layerMemory),
+  Layer.provideMerge(AuthorizationLayer)
+)
+
+// The client-side Authorization middleware supplies the bearer token.
+// Providing different middleware implementations lets the tests cover both
+// authorized and unauthorized requests.
+const AuthorizationMiddlewareGood = HttpApiMiddleware.layerClient(
+  Authorization,
+  ({ next, request }) => next(HttpClientRequest.bearerToken(request, "dev-token"))
+)
+
+const AuthorizationMiddlewareBad = HttpApiMiddleware.layerClient(
+  Authorization,
+  // Forward the request without attaching a token
+  ({ next, request }) => next(request)
+)
+
+// `HttpApiTest.groups` builds a typed client wired directly to the handlers of
+// the selected groups, using the same request encoding, routing, and response
+// decoding as a real server.
+const makeClient = HttpApiTest.groups(Api, ["users"])
+
+// `HttpServer.layerServices` provides the platform services the HTTP pipeline
+// needs in tests.
+layer(Layer.mergeAll(HandlersLayer, HttpServer.layerServices))("UsersApi", (it) => {
+  it.effect("lists, fetches, and creates users", () =>
+    Effect.gen(function*() {
+      const client = yield* makeClient
+
+      const created = yield* client.users.create({
+        payload: { name: "Alice", email: "alice@acme.dev" }
+      })
+      assert.strictEqual(created.name, "Alice")
+
+      const fetched = yield* client.users.getById({
+        params: { id: created.id }
+      })
+      assert.deepStrictEqual(fetched, created)
+
+      const all = yield* client.users.list({ query: {} })
+      assert.isTrue(all.some((user) => user.id === created.id))
+    }).pipe(Effect.provide(AuthorizationMiddlewareGood)))
+
+  it.effect("returns a 404 for a missing user", () =>
+    Effect.gen(function*() {
+      const client = yield* makeClient
+
+      // Use Effect.flip to assert on the error channel
+      const error = yield* client.users.getById({
+        params: { id: UserId.make("019845e1-682f-4b02-a706-3b2422d13aec") }
+      }).pipe(Effect.flip)
+      assert.strictEqual(error._tag, "UserNotFound")
+    }).pipe(Effect.provide(AuthorizationMiddlewareGood)))
+
+  it.effect("rejects requests without a valid bearer token", () =>
+    Effect.gen(function*() {
+      const client = yield* makeClient
+
+      const error = yield* client.users.list({ query: {} }).pipe(Effect.flip)
+      assert.strictEqual(error._tag, "Unauthorized")
+    }).pipe(Effect.provide(AuthorizationMiddlewareBad)))
+
+  it.effect("rejects requests with an invalid bearer token", () =>
+    Effect.gen(function*() {
+      const client = yield* makeClient
+
+      const error = yield* client.users.getById({
+        params: { id: UserId.make("019845e1-682f-4b02-a706-3b2422d13aec") }
+      }).pipe(Effect.flip)
+      assert.strictEqual(error._tag, "Unauthorized")
+    }).pipe(
+      Effect.provide(HttpApiMiddleware.layerClient(
+        Authorization,
+        ({ next, request }) => next(HttpClientRequest.bearerToken(request, "wrong-token"))
+      ))
+    ))
+})

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/fixtures/api/Users.ts

@@ -10,7 +10,10 @@ export class UsersApiGroup extends HttpApiGroup.make("users")
       query: {
         search: Schema.optional(Schema.String)
       },
-      success: Schema.Array(User)
+      // Use the `json` variant of the model for API responses. It shares the
+      // field declarations with the database variants, but can encode values
+      // differently where needed.
+      success: Schema.Array(User.json)
     }),
     HttpApiEndpoint.get("search", "/search", {
       // For get requests, payload uses the query string
@@ -18,7 +21,7 @@ export class UsersApiGroup extends HttpApiGroup.make("users")
         search: Schema.String
       },
       success: [
-        Schema.Array(User),
+        Schema.Array(User.json),
         Schema.String.pipe(HttpApiSchema.asText({
           contentType: "text/csv"
         }))
@@ -39,13 +42,12 @@ export class UsersApiGroup extends HttpApiGroup.make("users")
     }),
     HttpApiEndpoint.get("getById", "/:id", {
       params: {
-        // Path parameter schemas need to be able to decode from strings.
-        // Schema.decodeTo can be used to "bridge" between schemas
-        id: Schema.FiniteFromString.pipe(
-          Schema.decodeTo(UserId)
-        )
+        // Path parameter values are automatically coerced from their string
+        // form using `Schema.toCodecStringTree`, so schemas that decode from
+        // other types (like numbers) work here as well.
+        id: UserId
       },
-      success: User,
+      success: User.json,
       error: UserNotFound.pipe(
         // If you want an error to return no content, you can use
         // `HttpApiSchema.asNoContent` and provide a decoder that transforms the
@@ -59,14 +61,28 @@ export class UsersApiGroup extends HttpApiGroup.make("users")
       // For post requests, payload uses the request body. It defaults to JSON,
       // but you can specify other content types as well using
       // `HttpApiSchema.asText`, `HttpApiSchema.asMultipart`, etc.
-      payload: Schema.Struct({
-        name: Schema.String,
-        email: Schema.String
-      }),
-      success: User
+      //
+      // The `jsonCreate` variant only exposes the fields clients are allowed
+      // to provide, so the generated id and timestamps cannot be set here.
+      payload: User.jsonCreate,
+      success: User.json
+    }),
+    HttpApiEndpoint.patch("update", "/:id", {
+      params: {
+        id: UserId
+      },
+      // The `jsonUpdate` variant similarly excludes the id and the managed
+      // timestamps from the update payload.
+      payload: User.jsonUpdate,
+      success: User.json,
+      error: UserNotFound.pipe(
+        HttpApiSchema.asNoContent({
+          decode: () => new UserNotFound()
+        })
+      )
     }),
     HttpApiEndpoint.get("me", "/me", {
-      success: User,
+      success: User.json,
       error: UserNotFound.pipe(HttpApiSchema.status(404))
     })
   )

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/fixtures/domain/User.ts

@@ -1,12 +1,21 @@
 import { Schema } from "effect"
+import { Model } from "effect/unstable/schema"
 
-export const UserId = Schema.Int.pipe(
-  Schema.brand("UserId")
-)
+export const UserId = Schema.String.pipe(Schema.brand("UserId"))
 export type UserId = typeof UserId.Type
 
-export class User extends Schema.Class<User>("User")({
-  id: UserId,
+// `Model.Class` derives variants for the database (`User`, `User.insert`,
+// `User.update`) and the JSON API (`User.json`, `User.jsonCreate`,
+// `User.jsonUpdate`) from a single field declaration.
+export class User extends Model.Class<User>("User")({
+  // A UUID v4 primary key generated by the application on insert. It is
+  // excluded from the `jsonCreate` / `jsonUpdate` variants, so API clients can
+  // never set it.
+  id: Model.UuidV4Insert(UserId),
   name: Schema.String,
-  email: Schema.String
+  email: Schema.String,
+  // Timestamps are managed by the model: set on insert, refreshed on update,
+  // and also excluded from the JSON create / update variants.
+  createdAt: Model.DateTimeInsert,
+  updatedAt: Model.DateTimeUpdate
 }) {}

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/fixtures/server/Authorization.ts

@@ -1,7 +1,16 @@
-import { Effect, Layer, Redacted } from "effect"
+import { DateTime, Effect, Layer, Redacted } from "effect"
 import { Authorization, CurrentUser, Unauthorized } from "../api/Authorization.ts"
 import { User, UserId } from "../domain/User.ts"
 
+const fixedTimestamp = DateTime.makeUnsafe("2026-01-01T00:00:00Z")
+const devUser = new User({
+  id: UserId.make("bf3dbe33-0ad2-4c9c-9c9e-733e57bdcbee"),
+  name: "Dev User",
+  email: "dev@acme.com",
+  createdAt: fixedTimestamp,
+  updatedAt: fixedTimestamp
+})
+
 // The implementation of the Authorization middleware. It is seperate from the
 // service definition to avoid leaking it into a client.
 export const AuthorizationLayer = Layer.effect(
@@ -21,15 +30,7 @@ export const AuthorizationLayer = Layer.effect(
 
         // Provide the current user to the rest of the stack. This will be
         // available in any endpoint or middleware that runs after this one.
-        return yield* Effect.provideService(
-          httpEffect,
-          CurrentUser,
-          new User({
-            id: UserId.make(1),
-            name: "Dev User",
-            email: "dev@acme.com"
-          })
-        )
+        return yield* Effect.provideService(httpEffect, CurrentUser, devUser)
       })
     })
   })

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/fixtures/server/Users/http.ts

@@ -5,49 +5,48 @@ import { CurrentUser } from "../../api/Authorization.ts"
 import { AuthorizationLayer } from "../Authorization.ts"
 import { Users } from "../Users.ts"
 
-export const UsersApiHandlers = HttpApiBuilder.group(
+// The handlers without their dependencies provided, so tests can supply an
+// alternative `Users` implementation.
+export const UsersApiHandlersNoDeps = HttpApiBuilder.group(
   Api,
   "users",
   Effect.fn(function*(handlers) {
     const users = yield* Users
 
-    return handlers
-      .handle("list", ({ query }) =>
+    return handlers.handleAll({
+      list: ({ query }) =>
         users.list(query.search).pipe(
           // The list endpoint expects no errors, so we convert any potential
           // errors into a 500 Internal Server Error.
           Effect.orDie
-        ))
-      .handle(
-        "search",
-        Effect.fn(function*({ payload }) {
-          if (payload.search === "bad-request") {
-            // You can use the built in error types like any other
-            // Schema.TaggedError
-            return yield* new HttpApiError.RequestTimeout()
-          }
-          return yield* users.list(payload.search).pipe(
-            Effect.catchReason(
-              "UsersError",
-              "SearchQueryTooShort",
-              // Re-fail the "SearchQueryTooShort" reason
-              Effect.fail,
-              // All other reasons are unexpected, so we convert them into a 500
-              // Internal Server Error.
-              Effect.die
-            )
+        ),
+      search: Effect.fn(function*({ payload }) {
+        if (payload.search === "bad-request") {
+          // You can use the built in error types like any other
+          // Schema.TaggedError
+          return yield* new HttpApiError.RequestTimeout()
+        }
+        return yield* users.list(payload.search).pipe(
+          Effect.catchReason(
+            "UsersError",
+            "SearchQueryTooShort",
+            // Re-fail the "SearchQueryTooShort" reason
+            Effect.fail,
+            // All other reasons are unexpected, so we convert them into a 500
+            // Internal Server Error.
+            Effect.die
           )
-        })
-      )
-      .handle("getById", ({ params }) =>
+        )
+      }),
+      getById: ({ params }) =>
         users.getById(params.id).pipe(
           // You can also use Effect.catchReasons to handle multiple error
           // reasons at once
           Effect.catchReasons("UsersError", {
             UserNotFound: (e) => Effect.fail(e)
           }, Effect.die)
-        ))
-      .handle("create", ({ payload }) =>
+        ),
+      create: ({ payload }) =>
         users.create(payload).pipe(
           Effect.orDie
           // You could alse use Effect.unwrapReason to moves rror reasons up to
@@ -59,13 +58,23 @@ export const UsersApiHandlers = HttpApiBuilder.group(
           //   UserNotFound: Effect.die,
           //   SearchQueryTooShort: Effect.die
           // })
-        ))
-      .handle("me", () =>
+        ),
+      update: ({ params, payload }) =>
+        users.update(params.id, payload).pipe(
+          Effect.catchReasons("UsersError", {
+            UserNotFound: (e) => Effect.fail(e)
+          }, Effect.die)
+        ),
+      me: () =>
         // The Authorization middleware provides the CurrentUser service, so we
         // can access it here.
-        CurrentUser)
+        CurrentUser
+    })
   })
-).pipe(
-  // Provide the dependencies for the handlers.
+)
+
+// The handlers with all dependencies provided, ready to serve. The SQL-backed
+// `Users.layer` keeps the database wiring out of the server entrypoint.
+export const UsersApiHandlers = UsersApiHandlersNoDeps.pipe(
   Layer.provide([Users.layer, AuthorizationLayer])
 )

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/51_http-server/fixtures/server/Users.ts

@@ -1,28 +1,142 @@
-import { Context, Effect, Layer, Ref } from "effect"
-import { User, UserId } from "../domain/User.ts"
+import { SqliteClient, SqliteMigrator } from "@effect/sql-sqlite-node"
+import { Context, Effect, Layer, Schema } from "effect"
+import { SqlClient, SqlModel, SqlSchema } from "effect/unstable/sql"
+import { User } from "../domain/User.ts"
+import type { UserId } from "../domain/User.ts"
 import { SearchQueryTooShort, UserNotFound, UsersError } from "../domain/UserErrors.ts"
 
+// The SqlClient layer determines which database the SQL implementation talks
+// to. Swap it for another driver package to target a different database.
+const SqlLayer = SqliteClient.layer({ filename: ":memory:" })
+
+// Migrations are effects keyed by `<id>_<name>` that run once, in id order. A
+// real application would keep each migration in its own file and load them
+// with `SqliteMigrator.fromFileSystem` instead of an inline record.
+const MigratorLayer = SqliteMigrator.layer({
+  loader: SqliteMigrator.fromRecord({
+    "0001_create_users": Effect.gen(function*() {
+      const sql = yield* SqlClient.SqlClient
+      yield* sql`
+        CREATE TABLE users (
+          id TEXT PRIMARY KEY,
+          name TEXT NOT NULL,
+          email TEXT NOT NULL,
+          createdAt TEXT NOT NULL,
+          updatedAt TEXT NOT NULL
+        )
+      `
+    })
+  })
+})
+
 export class Users extends Context.Service<Users, {
   list(search: string | undefined): Effect.Effect<Array<User>, UsersError>
   getById(id: UserId): Effect.Effect<User, UsersError>
-  create(input: { readonly name: string; readonly email: string }): Effect.Effect<User, UsersError>
+  create(input: typeof User.jsonCreate.Type): Effect.Effect<User, UsersError>
+  update(id: UserId, input: typeof User.jsonUpdate.Type): Effect.Effect<User, UsersError>
 }>()("acme/Users") {
-  static readonly layer = Layer.effect(
+  // The SQL implementation only requires a `SqlClient`, so entrypoints and
+  // tests decide how the database is provided.
+  static readonly layerNoDeps = Layer.effect(
     Users,
     Effect.gen(function*() {
-      const users = new Map<number, User>([
-        [
-          1,
-          new User({
-            id: UserId.make(1),
-            name: "Admin",
-            email: "admin@acme.dev"
+      const sql = yield* SqlClient.SqlClient
+
+      // CRUD goes through a repository derived from the `User` model. Each
+      // operation uses the matching model variant to encode its input and
+      // decodes rows with the full model schema.
+      const repo = yield* SqlModel.makeRepository(User, {
+        tableName: "users",
+        spanPrefix: "Users",
+        idColumn: "id"
+      })
+
+      // Queries the repository does not cover are written with the `sql` tag
+      // and decoded with the model schema.
+      const listAll = SqlSchema.findAll({
+        Request: Schema.Void,
+        Result: User,
+        execute: () => sql`SELECT * FROM users ORDER BY createdAt`
+      })
+
+      const searchUsers = SqlSchema.findAll({
+        Request: Schema.String,
+        Result: User,
+        execute: (search) => {
+          const pattern = `%${search}%`
+          return sql`SELECT * FROM users WHERE name LIKE ${pattern} OR email LIKE ${pattern}`
+        }
+      })
+
+      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
+        if (search === undefined || search.length === 0) {
+          return yield* Effect.orDie(listAll())
+        } else if (search.length < SearchQueryTooShort.minimumLength) {
+          return yield* new UsersError({
+            reason: new SearchQueryTooShort()
           })
-        ]
-      ])
-      const nextId = yield* Ref.make(2)
+        }
+        yield* Effect.annotateCurrentSpan({ search })
+        return yield* Effect.orDie(searchUsers(search))
+      })
 
-      const list = Effect.fn("UsersRepo.list")(function*(search: string | undefined) {
+      const getById = Effect.fn("Users.getById")((id: UserId) =>
+        repo.findById(id).pipe(
+          Effect.catchTags({
+            NoSuchElementError: () => new UsersError({ reason: new UserNotFound() }),
+            // Database and encoding failures are unexpected, so treat them as
+            // defects to keep the service interface focused on domain errors.
+            SchemaError: Effect.die,
+            SqlError: Effect.die
+          })
+        )
+      )
+
+      const create = Effect.fn("Users.create")((input: typeof User.jsonCreate.Type) =>
+        // `User.insert.makeEffect` fills in the generated id and timestamps
+        // using the Effect clock, so tests can control them with `TestClock`.
+        User.insert.makeEffect(input).pipe(
+          Effect.flatMap(repo.insert),
+          Effect.orDie
+        )
+      )
+
+      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
+        // Ensure the user exists first, so a missing id fails with the domain
+        // error instead of a defect.
+        yield* getById(id)
+        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
+        return yield* repo.update(update).pipe(Effect.orDie)
+      })
+
+      return Users.of({ list, getById, create, update })
+    })
+  )
+
+  // The fully provided SQL implementation: the database client and migrations
+  // are implementation details, so this layer requires nothing.
+  static readonly layer: Layer.Layer<Users> = this.layerNoDeps.pipe(
+    Layer.provide(MigratorLayer.pipe(Layer.provideMerge(SqlLayer))),
+    Layer.orDie
+  )
+
+  // An in-memory implementation for tests, so the HTTP stack can be exercised
+  // without a database.
+  static readonly layerMemory = Layer.effect(
+    Users,
+    Effect.gen(function*() {
+      const users = new Map<UserId, User>()
+
+      const makeUser = (input: typeof User.jsonCreate.Type) =>
+        User.insert.makeEffect(input).pipe(
+          Effect.map((user) => new User(user)),
+          Effect.orDie
+        )
+
+      const admin = yield* makeUser({ name: "Admin", email: "admin@acme.dev" })
+      users.set(admin.id, admin)
+
+      const list = Effect.fn("Users.list")(function*(search: string | undefined) {
         const allUsers = Array.from(users.values())
         if (search === undefined || search.length === 0) {
           return allUsers
@@ -38,7 +152,7 @@ export class Users extends Context.Service<Users, {
         )
       })
 
-      const getById = Effect.fn("UsersRepo.getById")(function*(id: UserId) {
+      const getById = Effect.fn("Users.getById")(function*(id: UserId) {
         yield* Effect.annotateCurrentSpan({ id })
         const user = users.get(id)
         if (user === undefined) {
@@ -49,14 +163,21 @@ export class Users extends Context.Service<Users, {
         return user
       })
 
-      const create = Effect.fn("UsersRepo.create")(function*(input: { readonly name: string; readonly email: string }) {
-        const id = yield* Ref.getAndUpdate(nextId, (current) => current + 1)
-        const user = new User({ id: UserId.make(id), ...input })
+      const create = Effect.fn("Users.create")(function*(input: typeof User.jsonCreate.Type) {
+        const user = yield* makeUser(input)
         users.set(user.id, user)
         return user
       })
 
-      return Users.of({ list, getById, create })
+      const update = Effect.fn("Users.update")(function*(id: UserId, input: typeof User.jsonUpdate.Type) {
+        const existing = yield* getById(id)
+        const update = yield* User.update.makeEffect({ id, ...input }).pipe(Effect.orDie)
+        const updated = new User({ ...existing, ...update })
+        users.set(id, updated)
+        return updated
+      })
+
+      return Users.of({ list, getById, create, update })
     })
   )
 }

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/ai-docs/src/70_cli/10_basics.ts

@@ -5,7 +5,7 @@
  * handlers into a single executable command.
  */
 import { NodeRuntime, NodeServices } from "@effect/platform-node"
-import { Console, Effect } from "effect"
+import { Console, Effect, Option, Schema } from "effect"
 import { Argument, Command, Flag } from "effect/unstable/cli"
 
 // You can define flags outside of commands and reuse them across multiple
@@ -23,24 +23,41 @@ const tasks = Command.make("tasks").pipe(
     workspace,
     verbose: Flag.boolean("verbose").pipe(
       Flag.withAlias("v"),
-      Flag.withDescription("Print diagnostic output")
+      Flag.withDescription("Print diagnostic output"),
+      Flag.withDefault(false)
     )
   }),
   Command.withDescription("Track and manage tasks")
 )
 
+// Arguments and flags parse plain strings; use `withSchema` to validate or
+// transform the parsed value with any schema.
+const Email = Schema.String.pipe(
+  Schema.check(Schema.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, {
+    message: "Expected a valid email address"
+  }))
+)
+
 const create = Command.make(
   "create",
   {
     title: Argument.string("title").pipe(
-      Argument.withDescription("Task title")
+      Argument.withDescription("Task title"),
+      // Reject empty titles at parse time, so the handler only ever sees
+      // valid input
+      Argument.withSchema(Schema.NonEmptyString)
     ),
     priority: Flag.choice("priority", ["low", "normal", "high"]).pipe(
       Flag.withDescription("Priority for the new task"),
       Flag.withDefault("normal")
+    ),
+    assignee: Flag.string("assignee").pipe(
+      Flag.withDescription("Email address of the person to assign"),
+      Flag.withSchema(Email),
+      Flag.optional
     )
   },
-  Effect.fn(function*({ title, priority }) {
+  Effect.fn(function*({ assignee, priority, title }) {
     // Subcommands can read parent command input by yielding the parent command.
     const root = yield* tasks
 
@@ -49,6 +66,10 @@ const create = Command.make(
     }
 
     yield* Console.log(`Created "${title}" in ${root.workspace} with ${priority} priority`)
+
+    if (Option.isSome(assignee)) {
+      yield* Console.log(`Assigned to ${assignee.value}`)
+    }
   })
 ).pipe(
   Command.withDescription("Create a task"),
@@ -56,6 +77,10 @@ const create = Command.make(
     {
       command: "tasks create \"Ship 4.0\" --priority high",
       description: "Create a high-priority task"
+    },
+    {
+      command: "tasks create \"Ship 4.0\" --assignee dev@acme.com",
+      description: "Create a task assigned to a team member"
     }
   ])
 )
@@ -68,7 +93,8 @@ const list = Command.make(
       Flag.withDefault("open")
     ),
     json: Flag.boolean("json").pipe(
-      Flag.withDescription("Print machine-readable output")
+      Flag.withDescription("Print machine-readable output"),
+      Flag.withDefault(false)
     )
   },
   Effect.fn(function*({ status, json }) {

package/server/node_modules/@effect/platform-node/node_modules/@effect/platform-node-shared/dist/NodeChildProcessSpawner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NodeChildProcessSpawner.d.ts","sourceRoot":"","sources":["../src/NodeChildProcessSpawner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,cAAc,CAAA;AAIxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AAMnC,OAAO,KAAK,YAAY,MAAM,sCAAsC,CAAA;AAEpE,OAAO,EACL,mBAAmB,EAKpB,MAAM,6CAA6C,CAAA;AAomBpD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAC7B,mBAAmB,EACnB,KAAK,EACL,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACQ,CAAA;AAM3C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,YAAY,CAAC,eAAe,CAAC,CAAA;IAC1E,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;CAC9D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,YAChB,YAAY,CAAC,OAAO,KAC5B,iBAoCF,CAAA"}
+{"version":3,"file":"NodeChildProcessSpawner.d.ts","sourceRoot":"","sources":["../src/NodeChildProcessSpawner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,cAAc,CAAA;AAIxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAC/C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAA;AAMnC,OAAO,KAAK,YAAY,MAAM,sCAAsC,CAAA;AAEpE,OAAO,EACL,mBAAmB,EAKpB,MAAM,6CAA6C,CAAA;AAymBpD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAC7B,mBAAmB,EACnB,KAAK,EACL,UAAU,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CACQ,CAAA;AAM3C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,qBAAqB,CAAC,YAAY,CAAC,eAAe,CAAC,CAAA;IAC1E,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,YAAY,CAAC,WAAW,CAAC,CAAA;CAC9D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,YAChB,YAAY,CAAC,OAAO,KAC5B,iBAoCF,CAAA"}