effect 4.0.0-beta.105 → 4.0.0-beta.107

package/src/unstable/eventlog/EventLogMessage.ts

@@ -261,8 +261,8 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
  *
  * **Details**
  *
- * It includes the client public key, target store id, AES-GCM initialization
- * vector, and encrypted entries.
+ * It includes the client public key, target store id, and encrypted entries
+ * with their AES-GCM initialization vectors.
  *
  * @category protocols
  * @since 4.0.0
@@ -270,7 +270,6 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
 export class WriteEntries extends Schema.Class<WriteEntries>("effect/eventlog/EventLogRemote/WriteEntries")({
   publicKey: Schema.String,
   storeId: StoreId,
-  iv: Transferable.Uint8Array,
   encryptedEntries: Schema.Array(EncryptedEntry)
 }) {
   static FromMsgpack = Msgpack.schema(WriteEntries)

package/src/unstable/eventlog/EventLogRemote.ts

@@ -307,14 +307,14 @@ export const makeEncrypted = Effect.gen(function*(): Effect.fn.Return<
   return yield* makeWith({
     encodeWrite: (options) =>
       encryption.encrypt(options.identity, options.entries).pipe(
-        Effect.flatMap((msg) =>
+        Effect.flatMap((encryptedEntries) =>
           new WriteEntries({
             publicKey: options.identity.publicKey,
             storeId: options.storeId,
-            iv: msg.iv,
-            encryptedEntries: msg.encryptedEntries.map((entry, i) => ({
+            encryptedEntries: encryptedEntries.map((entry, i) => ({
               entryId: options.entries[i].id,
-              encryptedEntry: entry
+              iv: entry.iv,
+              encryptedEntry: entry.encryptedEntry
             }))
           }).encoded
         )

package/src/unstable/eventlog/EventLogServerEncrypted.ts

@@ -67,10 +67,10 @@ export const layerRpcHandlers = Layer.unwrap(Effect.gen(function*() {
         })
       }
       if (request.encryptedEntries.length === 0) return
-      const entries = request.encryptedEntries.map(({ encryptedEntry, entryId }) =>
+      const entries = request.encryptedEntries.map(({ encryptedEntry, entryId, iv }) =>
         new PersistedEntry({
           entryId,
-          iv: request.iv,
+          iv,
           encryptedEntry
         })
       )

package/src/unstable/http/HttpServerRequest.ts

@@ -436,14 +436,19 @@ export const toClientRequest = (request: HttpServerRequest): HttpClientRequest.H
     Option.getOrElse(toURL(request), () => request.url)
   )
 
-const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody =>
-  hasBody(request.method)
+const toClientBody = (request: HttpServerRequest): HttpBody.HttpBody => {
+  if (!hasBody(request.method)) {
+    return HttpBody.empty
+  }
+  const formData = getFormDataBody(request)
+  return formData === undefined
     ? HttpBody.stream(
       request.stream,
       request.headers["content-type"],
       parseContentLength(request.headers["content-length"])
     )
-    : HttpBody.empty
+    : HttpBody.formData(formData)
+}
 
 const parseContentLength = (contentLength: string | undefined): number | undefined => {
   if (contentLength === undefined) {

package/src/unstable/http/Multipart.ts

@@ -602,7 +602,7 @@ class FileImpl extends PartBase implements File {
     this.contentType = info.contentType
     this.content = Stream.fromChannel(channel)
     this.contentEffect = channel.pipe(
-      collectUint8Array,
+      Channel.mkUint8Array,
       Effect.mapError((cause) => MultipartError.fromReason("InternalError", cause))
     )
   }
@@ -635,24 +635,15 @@ const defaultWriteFile = (path: string, file: File) =>
  * **Gotchas**
  *
  * This materializes the full content in memory.
+ * The source channel must not reuse or mutate emitted buffers, which are retained
+ * until collection completes.
  *
  * @category converting
  * @since 4.0.0
  */
 export const collectUint8Array = <OE, OD, R>(
   self: Channel.Channel<Arr.NonEmptyReadonlyArray<Uint8Array>, OE, OD, unknown, unknown, unknown, R>
-): Effect.Effect<Uint8Array<ArrayBuffer>, OE, R> =>
-  Channel.runFold(self, constant(new Uint8Array(0)), (accumulator, chunk) => {
-    const totalLength = chunk.reduce((sum, element) => sum + element.length, accumulator.length)
-    const newAccumulator = new Uint8Array(totalLength)
-    newAccumulator.set(accumulator, 0)
-    let offset = accumulator.length
-    for (const element of chunk) {
-      newAccumulator.set(element, offset)
-      offset += element.length
-    }
-    return newAccumulator
-  })
+): Effect.Effect<Uint8Array<ArrayBuffer>, OE, R> => Channel.mkUint8Array(self)
 
 /**
  * Persists a stream of multipart parts into a record.

package/src/unstable/http/MultipartParser/internal/headers.ts

@@ -12,394 +12,23 @@ type State = (typeof State)[keyof typeof State]
 
 const constContinue: Continue = { _tag: "Continue" }
 
-const constNameChars = [
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  1,
-  1,
-  0,
-  1,
-  1,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  0,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  1,
-  0,
-  1
-]
+// RFC 7230 token characters, allowed in header names
+// The previous table stopped at byte 126; zero-filled entries for bytes 127-255
+// preserve its rejection behavior because callers accept only entries equal to 1.
+const constNameChars = new Uint8Array(256)
+for (const char of "!#$%&'*+-.^_`|~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+  constNameChars[char.charCodeAt(0)] = 1
+}
 
-const constValueChars = [
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  0,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1,
-  1
-]
+// HTAB, visible ASCII and obs-text, allowed in header values
+const constValueChars = new Uint8Array(256)
+constValueChars[9] = 1
+for (let i = 32; i <= 126; i++) {
+  constValueChars[i] = 1
+}
+for (let i = 128; i <= 255; i++) {
+  constValueChars[i] = 1
+}
 
 export function make() {
   const decoder = new TextDecoder()

package/src/unstable/http/MultipartParser/internal/multipart.ts

@@ -74,7 +74,8 @@ export function make({
     isFile: false,
     fieldChunks: [] as Array<Uint8Array>,
     fieldSize: 0,
-    done: false
+    done: false,
+    stopped: false
   }
 
   function skipBody() {
@@ -83,11 +84,23 @@ export function make({
     state.onChunk = noopOnChunk
   }
 
+  function stop(error: MultipartError) {
+    state.stopped = true
+    if (state.state === State.body && state.isFile) {
+      state.onChunk(null)
+    }
+    onError(error)
+  }
+
   const headerParser = HP.make()
 
   const split = Search.make(
     `\r\n--${boundary}`,
     function(index, chunk) {
+      if (state.stopped) {
+        return
+      }
+
       if (index === 0) {
         // data before the first boundary
         skipBody()
@@ -127,12 +140,12 @@ export function make({
 
         state.parts++
         if (state.parts > maxParts) {
-          onError(errMaxParts)
+          return stop(errMaxParts)
         }
       }
 
       if ((state.partSize += chunk.length) > maxPartSize) {
-        onError(errMaxPartSize)
+        return stop(errMaxPartSize)
       }
 
       if (state.state === State.headers) {
@@ -199,7 +212,7 @@ export function make({
           } else {
             const buf = chunk.subarray(result.endPosition)
             if ((state.fieldSize += buf.length) > maxFieldSize) {
-              onError(errMaxFieldSize)
+              return stop(errMaxFieldSize)
             }
             state.fieldChunks.push(buf)
           }
@@ -208,7 +221,7 @@ export function make({
         state.onChunk(chunk)
       } else {
         if ((state.fieldSize += chunk.length) > maxFieldSize) {
-          onError(errMaxFieldSize)
+          return stop(errMaxFieldSize)
         }
         state.fieldChunks.push(chunk)
       }
@@ -219,15 +232,18 @@ export function make({
 
   return {
     write(chunk: Uint8Array) {
+      if (state.stopped) {
+        return
+      }
       if ((state.totalSize += chunk.length) > maxTotalSize) {
-        return onError(errMaxTotalSize)
+        return stop(errMaxTotalSize)
       }
       return split.write(chunk)
     },
     end() {
       split.end()
-      if (!state.done) {
-        onError(errEndNotReached)
+      if (!state.done && !state.stopped) {
+        stop(errEndNotReached)
       }
 
       state.state = State.headers
@@ -240,6 +256,7 @@ export function make({
       state.fieldChunks = []
       state.fieldSize = 0
       state.done = false
+      state.stopped = false
     }
   } as const
 }

package/src/unstable/httpapi/OpenApi.ts

@@ -220,7 +220,10 @@ type CompileSchemas = (
 const compileSchemas: CompileSchemas = (asts) =>
   JsonSchema.toMultiDocumentOpenApi3_1(
     InternalToJsonSchemaDocument.toJsonSchemaMultiDocument(
-      InternalToRepresentation.toRepresentations(Arr.map(asts, Schema.toCodecJsonAST))
+      InternalToRepresentation.toRepresentations(
+        Arr.map(asts, Schema.toCodecJsonAST),
+        InternalToJsonSchemaDocument.toRepresentationOptions
+      )
     )
   )
 

package/src/unstable/process/ChildProcess.ts

@@ -432,6 +432,14 @@ export interface CommandOptions extends KillOptions {
    * Defaults to `true` on non-Windows platforms and `false` on Windows platforms.
    */
   readonly detached?: boolean | undefined
+  /**
+   * If set to `true`, prevents the child process's console or GUI window from
+   * becoming visible on Windows.
+   *
+   * Defaults to `true` unless `detached` is set to `true`. This option has no
+   * effect on non-Windows platforms.
+   */
+  readonly windowsHide?: boolean | undefined
   /**
    * Configuration options for the standard input stream for the child process.
    */

package/src/unstable/rpc/RpcClient.ts

@@ -1299,6 +1299,11 @@ export const makeProtocolWorker = (
           undefined
       }).pipe(
         Effect.tapCause((cause) => {
+          for (const [requestId, entry] of entries) {
+            if (entry.worker !== backing) continue
+            entries.delete(requestId)
+            entry.latch.openUnsafe()
+          }
           const error = Cause.findError(cause)
           return broadcast({
             _tag: "ClientProtocolError",

package/src/unstable/sql/Migrator.ts

@@ -15,6 +15,7 @@ import { FileSystem } from "../../FileSystem.ts"
 import { pipe } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Order from "../../Order.ts"
+import { Path } from "../../Path.ts"
 import * as Client from "./SqlClient.ts"
 import type { SqlError } from "./SqlError.ts"
 
@@ -400,11 +401,19 @@ export const fromRecord = (migrations: Record<string, Effect.Effect<void, unknow
  * files named `<id>_<name>.js`, `<id>_<name>.ts`,
  * `<id>_<name>.mjs`, or `<id>_<name>.mts`, and sorts migrations by id.
  *
+ * **Details**
+ *
+ * Requires a `Path` service appropriate for the migration directory's path
+ * syntax. On Windows, prefer a platform-aware implementation such as
+ * `NodePath.layer`; the core `Path.layer` uses POSIX semantics and does not
+ * preserve Windows drive-letter paths.
+ *
  * @category loaders
  * @since 4.0.0
  */
-export const fromFileSystem: (directory: string) => Loader<FileSystem> = Effect.fnUntraced(function*(directory) {
+export const fromFileSystem: (directory: string) => Loader<FileSystem | Path> = Effect.fnUntraced(function*(directory) {
   const Fs = yield* FileSystem
+  const path = yield* Path
   const files = yield* Effect.mapError(
     Fs.readDirectory(directory),
     (cause) =>
@@ -424,14 +433,18 @@ export const fromFileSystem: (directory: string) => Loader<FileSystem> = Effect.
             [
               Number(id),
               name,
-              Effect.promise(
-                () =>
-                  import(
-                    /* @vite-ignore */
-                    /* webpackIgnore: true */
-                    `${directory}/${basename}`
-                  )
-              )
+              // `import` needs a file URL: on Windows an absolute path such as
+              // `D:\migrations\1_init.ts` is rejected by the ESM loader. `orDie` keeps the
+              // failure a defect so `loadMigration` reports it as an import error.
+              Effect.flatMap(Effect.orDie(path.toFileUrl(path.join(directory, basename))), (url) =>
+                Effect.promise(
+                  () =>
+                    import(
+                      /* @vite-ignore */
+                      /* webpackIgnore: true */
+                      url.href
+                    )
+                ))
             ]
           ] as const
       })