effect 4.0.0-rc.118 → 4.0.1

package/src/cluster/internal/resourceRef.ts

@@ -1,133 +1,226 @@
-import type * as Cause from "../../Cause.ts"
+import * as Deferred from "../../Deferred.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
-import * as Latch from "../../Latch.ts"
-import * as MutableRef from "../../MutableRef.ts"
-import * as Option from "../../Option.ts"
+import * as Fiber from "../../Fiber.ts"
 import * as Scope from "../../Scope.ts"
 import type { EntityAddress } from "../EntityAddress.ts"
-import { acquireEntity, releaseEntity } from "./interruptors.ts"
+import { aroundEntity } from "./interruptors.ts"
 
-/**
- * @internal
- */
-export type State<A, E> = {
-  readonly _tag: "Closed"
-} | {
-  readonly _tag: "Acquiring"
-  readonly scope: Scope.Closeable
-} | {
-  readonly _tag: "Acquired"
-  readonly scope: Scope.Closeable
-  readonly value: A
-} | {
-  readonly _tag: "Failed"
+type Pending<A> = {
+  readonly _tag: "Pending"
   readonly scope: Scope.Closeable
-  readonly cause: Cause.Cause<E>
+  /** Predecessor scope or ongoing release to await before acquisition. */
+  readonly releases: Scope.Closeable | Fiber.Fiber<void> | undefined
+  releasing: boolean
+  /** Shared with waiters across superseded rebuilds. */
+  readonly ready: Deferred.Deferred<A>
+  value: A | undefined
+  work: Fiber.Fiber<void> | undefined
 }
 
+type State<A> =
+  | { readonly _tag: "Closed" }
+  | { readonly _tag: "Ready"; readonly scope: Scope.Closeable; readonly value: A }
+  | Pending<A>
+  | {
+    readonly _tag: "Failed"
+    readonly ready: Deferred.Deferred<A>
+    readonly releasing: Fiber.Fiber<void> | undefined
+  }
+
 /**
+ * A replaceable resource whose acquired value identifies its generation.
+ *
  * @internal
  */
-export class ResourceRef<A, E = never> {
-  static from = Effect.fnUntraced(function*<A, E>(
+export class ResourceRef<A> {
+  static from = Effect.fnUntraced(function*<A>(
     parentScope: Scope.Scope,
-    acquire: (scope: Scope.Scope) => Effect.Effect<A, E>,
+    acquire: (scope: Scope.Scope) => Effect.Effect<A>,
     teardownAddress?: EntityAddress
   ) {
-    const state = MutableRef.make<State<A, E>>({ _tag: "Closed" })
-
-    yield* Scope.addFinalizerExit(parentScope, (exit) => {
-      const s = MutableRef.get(state)
-      if (s._tag === "Closed") {
-        return Effect.void
-      }
-      const scope = s.scope
-      MutableRef.set(state, { _tag: "Closed" })
-      return Scope.close(scope, exit)
-    })
-
-    const scope = yield* Scope.make()
-    MutableRef.set(state, { _tag: "Acquiring", scope })
-    const value = yield* acquire(scope)
-    MutableRef.set(state, { _tag: "Acquired", scope, value })
-
-    return new ResourceRef(state, acquire, teardownAddress)
+    // Close the ref before joining releases, so waiters wake even if release stalls.
+    const releaseScope = Scope.forkUnsafe(parentScope)
+    const ref = new ResourceRef(releaseScope, acquire, teardownAddress)
+    yield* Scope.addFinalizerExit(parentScope, (exit) => ref.close(exit))
+    const pending = ref.pending(undefined, Deferred.makeUnsafe())
+    const value = yield* acquire(pending.scope)
+    if (ref.state === pending) ref.publish(pending, value)
+    return ref
   })
 
-  readonly state: MutableRef.MutableRef<State<A, E>>
-  readonly acquire: (scope: Scope.Scope) => Effect.Effect<A, E>
-  readonly teardownAddress: EntityAddress | undefined
-  constructor(
-    state: MutableRef.MutableRef<State<A, E>>,
-    acquire: (scope: Scope.Scope) => Effect.Effect<A, E>,
-    teardownAddress?: EntityAddress
+  private state: State<A> = { _tag: "Closed" }
+  private readonly releaseScope: Scope.Scope
+  private readonly acquire: (scope: Scope.Scope) => Effect.Effect<A>
+  private readonly teardownAddress: EntityAddress | undefined
+  private constructor(
+    releaseScope: Scope.Scope,
+    acquire: (scope: Scope.Scope) => Effect.Effect<A>,
+    teardownAddress: EntityAddress | undefined
   ) {
-    this.state = state
+    this.releaseScope = releaseScope
     this.acquire = acquire
     this.teardownAddress = teardownAddress
   }
 
-  latch = Latch.makeUnsafe(true)
+  /** Returns the value only after acquisition and preparation complete. */
+  getUnsafe(): A | undefined {
+    return this.state._tag === "Ready" ? this.state.value : undefined
+  }
+
+  /** Waits for a ready value; interrupts when the ref closes. */
+  readonly await: Effect.Effect<A> = Effect.suspend(() => {
+    const s = this.state
+    switch (s._tag) {
+      case "Closed":
+        return Effect.interrupt
+      case "Ready":
+        return Effect.succeed(s.value)
+      case "Pending":
+      case "Failed":
+        return Deferred.await(s.ready)
+    }
+  })
 
-  getUnsafe(): Option.Option<A> {
-    if (this.state.current._tag === "Acquired") {
-      return Option.some(this.state.current.value)
+  /**
+   * Replaces the generation, holding waiters until acquisition and `prepare` finish.
+   * Returns `undefined` if closed, if `from` differs from the ready or preparing
+   * value, or if `from` is omitted while a rebuild is pending.
+   *
+   * Acceptance immediately blocks waiters; run the returned effect to release
+   * the predecessor and build its replacement. Closing or superseding the ref
+   * interrupts the rebuild. Failure wakes waiters with its cause; the next
+   * rebuild must omit `from` and await cleanup. Interruption during predecessor
+   * release instead carries waiters forward without awaiting that release again.
+   */
+  rebuildUnsafe(options?: {
+    readonly from?: A | undefined
+    readonly prepare?: ((value: A) => Effect.Effect<void>) | undefined
+  }): Effect.Effect<void> | undefined {
+    const s = this.state
+    const from = options?.from
+    let pending: Pending<A>
+    switch (s._tag) {
+      case "Closed":
+        return undefined
+      case "Ready": {
+        if (from !== undefined && from !== s.value) return undefined
+        pending = this.pending(s.scope, Deferred.makeUnsafe())
+        break
+      }
+      case "Failed": {
+        if (from !== undefined) return undefined
+        pending = this.pending(s.releasing, s.ready)
+        break
+      }
+      case "Pending": {
+        if (from === undefined || s.value !== from) return undefined
+        s.work?.interruptUnsafe()
+        pending = this.pending(s.scope, s.ready)
+        break
+      }
     }
-    return Option.none()
+    return this.run(pending, options?.prepare)
   }
 
-  rebuildUnsafe(): Effect.Effect<void, E> {
-    const s = this.state.current
-    if (s._tag === "Closed") {
-      return Effect.interrupt
+  private pending(
+    releases: Scope.Closeable | Fiber.Fiber<void> | undefined,
+    ready: Deferred.Deferred<A>
+  ): Pending<A> {
+    const pending: Pending<A> = {
+      _tag: "Pending",
+      scope: Scope.makeUnsafe(),
+      releases,
+      releasing: false,
+      ready,
+      value: undefined,
+      work: undefined
     }
-    const prevScope = s.scope
-    const scope = Scope.makeUnsafe()
-    this.latch.closeUnsafe()
-    MutableRef.set(this.state, { _tag: "Acquiring", scope })
-    const teardownAddress = this.teardownAddress
-    return Effect.suspend(() => {
-      const close = Scope.close(prevScope, Exit.void)
-      if (!teardownAddress) return close
-      acquireEntity(teardownAddress)
-      return Effect.ensuring(close, Effect.sync(() => releaseEntity(teardownAddress)))
+    this.state = pending
+    return pending
+  }
+
+  private publish(pending: Pending<A>, value: A): void {
+    this.state = { _tag: "Ready", scope: pending.scope, value }
+    Deferred.doneUnsafe(pending.ready, Exit.succeed(value))
+  }
+
+  private run(pending: Pending<A>, prepare: ((value: A) => Effect.Effect<void>) | undefined): Effect.Effect<void> {
+    const work = Effect.suspend(() => {
+      if (this.state !== pending) return Effect.interrupt
+      const releases = pending.releases
+      if (!releases) return Effect.void
+      pending.releasing = true
+      return Effect.andThen(
+        Fiber.isFiber(releases) ? Fiber.join(releases) : Effect.flatMap(this.release(releases), Fiber.join),
+        Effect.sync(() => {
+          pending.releasing = false
+        })
+      )
     }).pipe(
-      Effect.andThen(this.acquire(scope)),
+      Effect.andThen(Effect.suspend(() => this.acquire(pending.scope))),
+      Effect.tap((value) => {
+        if (this.state !== pending) return Effect.interrupt
+        pending.value = value
+        return prepare ? prepare(value) : Effect.void
+      }),
       Effect.flatMap((value) => {
-        if (this.state.current._tag === "Closed") {
-          return Effect.interrupt
-        }
-        MutableRef.set(this.state, { _tag: "Acquired", scope, value })
-        return this.latch.open
-      })
-    ).pipe(
+        if (this.state !== pending) return Effect.interrupt
+        this.publish(pending, value)
+        return Effect.void
+      }),
       Effect.onExit((exit) => {
-        if (Exit.isSuccess(exit)) {
+        if (Exit.isSuccess(exit) || this.state !== pending) {
+          return Effect.void
+        }
+        if (pending.releasing) {
+          // No resource was acquired. Carry waiters forward without rejoining the stalled release.
+          this.state = { _tag: "Failed", ready: pending.ready, releasing: undefined }
           return Effect.void
         }
-        return Scope.close(scope, exit).pipe(
-          Effect.ensuring(Effect.sync(() => {
-            const state = this.state.current
-            if (state._tag === "Acquiring" && state.scope === scope) {
-              MutableRef.set(this.state, { _tag: "Failed", scope, cause: exit.cause })
-              this.latch.openUnsafe()
-            }
-          }))
-        )
+        return Effect.map(this.release(pending.scope), (releasing) => {
+          if (this.state !== pending) return
+          this.state = { _tag: "Failed", ready: Deferred.makeUnsafe(), releasing }
+          Deferred.doneUnsafe(pending.ready, Exit.failCause(exit.cause))
+        })
       })
     )
+    return Effect.flatMap(Effect.forkChild(work, { startImmediately: true }), (fiber) => {
+      pending.work = fiber
+      // Replaced or closed before the fiber handle existed.
+      if (this.state !== pending) fiber.interruptUnsafe()
+      return Fiber.join(fiber)
+    })
   }
 
-  await: Effect.Effect<A, E> = Effect.suspend(() => {
-    const s = this.state.current
-    if (s._tag === "Closed") {
-      return Effect.interrupt
-    } else if (s._tag === "Acquired") {
-      return Effect.succeed(s.value)
-    } else if (s._tag === "Failed") {
-      return Effect.failCause(s.cause)
+  // A stalled release must not prevent rebuild interruption.
+  private release(scope: Scope.Closeable): Effect.Effect<Fiber.Fiber<void>> {
+    const close = Scope.close(scope, Exit.void)
+    return Effect.forkIn(
+      this.teardownAddress ? aroundEntity(this.teardownAddress, close) : close,
+      this.releaseScope,
+      { startImmediately: true }
+    )
+  }
+
+  private close(exit: Exit.Exit<unknown, unknown>): Effect.Effect<void> {
+    const s = this.state
+    this.state = { _tag: "Closed" }
+    switch (s._tag) {
+      case "Closed":
+        return Effect.void
+      case "Ready":
+        return Scope.close(s.scope, exit)
+      case "Failed": {
+        Deferred.doneUnsafe(s.ready, Effect.interrupt)
+        return Effect.void
+      }
+      case "Pending": {
+        Deferred.doneUnsafe(s.ready, Effect.interrupt)
+        s.work?.interruptUnsafe()
+        const close = Scope.close(s.scope, exit)
+        return s.releases && !Fiber.isFiber(s.releases) ? Effect.andThen(Scope.close(s.releases, exit), close) : close
+      }
     }
-    return Effect.flatMap(this.latch.await, () => this.await)
-  })
+  }
 }

package/src/http/HttpEffect.ts

@@ -32,6 +32,7 @@ import * as preResponseHandler from "./internal/preResponseHandler.ts"
 
 /**
  * Runs an HTTP server effect, sends the produced response with the supplied handler, and converts failures into HTTP responses.
+ * On handler failure, the request scope closes with the original cause.
  *
  * @stability unstable
  * @category combinators
@@ -45,8 +46,10 @@ export const toHandled = <E, R, EH, RH>(
   ) => Effect.Effect<unknown, EH, RH>,
   middleware?: HttpMiddleware | undefined
 ): Effect.Effect<void, never, Exclude<R | RH | HttpServerRequest, Scope.Scope>> => {
-  const handleCause = (request: HttpServerRequest, cause: Cause.Cause<E | EH | HttpServerError>) =>
-    Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
+  const handleCause = (frame: RequestFrame, cause: Cause.Cause<E | EH | HttpServerError>) => {
+    frame.cause = cause
+    const request = frame.request
+    return Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
       const handler = preResponseHandler.requestPreResponseHandlers.get(request.source)
@@ -67,6 +70,7 @@ export const toHandled = <E, R, EH, RH>(
         () => cont
       )
     })
+  }
 
   // Writes the response, applying any registered pre-response handler first.
   // Returns an `Exit` when the write completes synchronously.
@@ -85,14 +89,15 @@ export const toHandled = <E, R, EH, RH>(
     })
   }
 
-  const withMiddleware = (request: HttpServerRequest): Effect.Effect<
+  const withMiddleware = (frame: RequestFrame): Effect.Effect<
     unknown,
     E | EH | HttpServerError,
     HttpServerRequest | R | RH
   > => {
+    const request = frame.request
     const responded = Effect.matchCauseEffect(self, {
       onSuccess: (response) => sendResponse(request, response),
-      onFailure: (cause) => handleCause(request, cause)
+      onFailure: (cause) => handleCause(frame, cause)
     })
     return middleware === undefined ?
       responded :
@@ -116,9 +121,9 @@ export const toHandled = <E, R, EH, RH>(
   }
 
   // Apply tracing lazily so disabled requests can use the single-frame path.
-  const traced = (request: HttpServerRequest) =>
+  const traced = (frame: RequestFrame) =>
     tracer(
-      withMiddleware(request) as Effect.Effect<
+      withMiddleware(frame) as Effect.Effect<
         HttpServerResponse,
         E | EH | HttpServerError,
         HttpServerRequest | R | RH
@@ -135,13 +140,14 @@ export const toHandled = <E, R, EH, RH>(
     Effect.onExitPrimitive(effect, (exit) => {
       fiber.setContext(frame.prev)
       if (scopeEjected in frame.scope) return undefined
-      return Scope.closeUnsafe(frame.scope, exit)
+      return Scope.closeUnsafe(frame.scope, frame.cause === undefined ? exit : Exit.failCause(frame.cause))
     }, true)
 
   class RequestFrame {
     readonly scope: Scope.Closeable
     readonly prev: Context.Context<never>
     readonly request: HttpServerRequest
+    cause: Cause.Cause<E | EH | HttpServerError> | undefined
     constructor(scope: Scope.Closeable, prev: Context.Context<never>, request: HttpServerRequest) {
       this.scope = scope
       this.prev = prev
@@ -159,7 +165,7 @@ export const toHandled = <E, R, EH, RH>(
       return finishAfter(this, fiber, sent)
     }
     [contE](cause: Cause.Cause<E | EH | HttpServerError>, fiber: Fiber.Fiber<unknown, unknown>) {
-      return finishAfter(this, fiber, handleCause(this.request, cause))
+      return finishAfter(this, fiber, handleCause(this, cause))
     }
   }
 
@@ -177,7 +183,7 @@ export const toHandled = <E, R, EH, RH>(
       ;(fiber as any)._stack.push(frame)
       return self
     }
-    return finishAfter(frame, fiber, middleware === undefined ? traced(frame.request) : withMiddleware(frame.request))
+    return finishAfter(frame, fiber, middleware === undefined ? traced(frame) : withMiddleware(frame))
   }) as any
 }
 

package/src/http/HttpMiddleware.ts

@@ -26,7 +26,7 @@ import { nativeTracer, ParentSpan, Tracer } from "../Tracer.ts"
 import * as Headers from "./Headers.ts"
 import type { CompressionAlgorithm } from "./HttpPlatform.ts"
 import { HttpPlatform } from "./HttpPlatform.ts"
-import { causeResponseStripped } from "./HttpServerError.ts"
+import { causeResponseStripped, ClientAbort } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
@@ -158,8 +158,14 @@ export const logger: <E, R>(
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)
+          const message = Option.isSome(cause) &&
+              !cause.value.reasons.every((reason) =>
+                reason._tag === "Interrupt" && reason.annotations.has(ClientAbort.key)
+              )
+            ? cause.value
+            : "Sent HTTP response"
           return Effect.andThen(
-            Effect.annotateLogs(Effect.log(Option.getOrElse(cause, () => "Sent HTTP Response")), {
+            Effect.annotateLogs(Effect.log(message), {
               "http.method": request.method,
               "http.url": path,
               "http.status": response.status

package/src/http/HttpStaticServer.ts

@@ -140,6 +140,14 @@ export const make: (options: {
         return yield* getFullResponse()
       }
 
+      const ifRange = request.headers["if-range"]
+      if (ifRange !== undefined) {
+        fullResponse = yield* getFullResponse()
+        if (!matchesIfRange(ifRange, fullResponse.headers["etag"])) {
+          return fullResponse
+        }
+      }
+
       const resolvedFileSize = fileSize ?? (yield* handlePlatformError(request, fileSystem.stat(filePath))).size
       const parsedRange = parseRange(rangeHeader, resolvedFileSize)
 
@@ -459,6 +467,14 @@ const isNotModifiedSince = (ifModifiedSince: string, lastModified: string | unde
   return lastModifiedMs <= ifModifiedSinceMs
 }
 
+// Only a strong entity-tag can match (RFC 9110 §13.1.5). Weak tags start
+// with `W/`, and Last-Modified dates never match: filesystem metadata cannot
+// prove the file did not change twice within the same second.
+const matchesIfRange = (ifRange: string, etag: string | undefined): boolean => {
+  const value = ifRange.trim()
+  return value.startsWith("\"") && value === etag
+}
+
 const notModifiedResponse = (
   response: HttpServerResponse.HttpServerResponse
 ): HttpServerResponse.HttpServerResponse => {

package/src/http/HttpTraceContext.ts

@@ -99,7 +99,7 @@ export const b3: FromHeaders = (headers) => {
   return Option.some(Tracer.externalSpan({
     traceId: parts[0],
     spanId: parts[1],
-    sampled: parts[2] ? parts[2] === "1" : true
+    sampled: parts[2] ? parts[2] === "1" || parts[2] === "d" : true
   }))
 }
 
@@ -109,7 +109,7 @@ export const b3: FromHeaders = (headers) => {
  * **Details**
  *
  * The decoder reads `x-b3-traceid`, `x-b3-spanid`, and optional `x-b3-sampled`
- * headers.
+ * and `x-b3-flags` headers. Debug flags override the sampling decision.
  *
  * @stability unstable
  * @category decoding
@@ -122,7 +122,8 @@ export const xb3: FromHeaders = (headers) => {
   return Option.some(Tracer.externalSpan({
     traceId: headers["x-b3-traceid"],
     spanId: headers["x-b3-spanid"],
-    sampled: headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" : true
+    sampled: headers["x-b3-flags"] === "1" ||
+      (headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" || headers["x-b3-sampled"] === "true" : true)
   }))
 }
 
@@ -151,7 +152,10 @@ export const w3c: FromHeaders = (headers) => {
   const [version, traceId, spanId, flags] = parts
   switch (version) {
     case "00": {
-      if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false) {
+      if (
+        w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false ||
+        traceId === "00000000000000000000000000000000" || spanId === "0000000000000000"
+      ) {
         return Option.none()
       }
       return Option.some(Tracer.externalSpan({

package/src/http-api/HttpApiError.ts

@@ -479,6 +479,7 @@ export class HttpApiSchemaError extends Data.TaggedClass("HttpApiSchemaError")<{
   readonly cause: Schema.SchemaError
 }> {
   readonly [HttpApiSchemaErrorTypeId]: HttpApiSchemaErrorTypeId = HttpApiSchemaErrorTypeId
+  readonly [ErrorReporter.ignore] = true
 
   static is(u: unknown): u is HttpApiSchemaError {
     return hasProperty(u, HttpApiSchemaErrorTypeId)

package/src/internal/core.ts

@@ -279,6 +279,48 @@ export const causeFromReasons = <E>(
   reasons: ReadonlyArray<Cause.Reason<E>>
 ): Cause.Cause<E> => new CauseImpl(reasons)
 
+const dedupeReasons = <E>(
+  self: ReadonlyArray<Cause.Reason<E>>,
+  that: ReadonlyArray<Cause.Reason<E>>
+): Array<Cause.Reason<E>> => {
+  // Avoid importing Array.ts into the core bundle.
+  // Snapshot both arrays before invoking user-defined hash or equality methods.
+  const buckets = new Map<number, Array<Cause.Reason<E>>>()
+  const out: Array<Cause.Reason<E>> = []
+  for (const reason of self.concat(that)) {
+    const hash = Hash.hash(reason)
+    const bucket = buckets.get(hash)
+    if (bucket === undefined) {
+      buckets.set(hash, [reason])
+    } else if (bucket.some((previous) => Equal.equals(previous, reason))) {
+      continue
+    } else {
+      bucket.push(reason)
+    }
+    out.push(reason)
+  }
+  return out
+}
+
+/** @internal */
+export const causeCombine: {
+  <E2>(that: Cause.Cause<E2>): <E>(self: Cause.Cause<E>) => Cause.Cause<E | E2>
+  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2>
+} = dual(
+  2,
+  <E, E2>(self: Cause.Cause<E>, that: Cause.Cause<E2>): Cause.Cause<E | E2> => {
+    if (self.reasons.length === 0) {
+      return that as Cause.Cause<E | E2>
+    } else if (that.reasons.length === 0) {
+      return self as Cause.Cause<E | E2>
+    }
+    const newCause = new CauseImpl<E | E2>(
+      dedupeReasons<E | E2>(self.reasons, that.reasons)
+    )
+    return Equal.equals(self, newCause) ? self : newCause
+  }
+)
+
 /** @internal */
 export const causeEmpty: Cause.Cause<never> = new CauseImpl([])
 
@@ -546,8 +588,20 @@ export const exitFailCause: <E>(cause: Cause.Cause<E>) => Exit.Exit<never, E> =
       annotated = true
     }
     let cont = fiber.getCont(contE)
-    while (fiber.interruptible && fiber._interruptedCause && cont) {
-      cont = fiber.getCont(contE)
+    const interruptedCause = fiber._interruptedCause
+    if (interruptedCause && fiber.interruptible) {
+      // Drop typed failures only when interruption skips a recovery handler.
+      // Interruptibility-restoration continuations have no identifier.
+      let skippedHandler = false
+      while (cont && fiber.interruptible) {
+        skippedHandler ||= identifier in cont
+        cont = fiber.getCont(contE)
+      }
+      if (skippedHandler) {
+        cause = causeFromReasons(cause.reasons.filter((reason) => reason._tag !== "Fail"))
+      }
+      cause = causeCombine(cause, interruptedCause)
+      annotated = true
     }
     return cont
       ? cont[contE](cause, fiber, annotated ? undefined : this)

package/src/internal/dateTime.ts

@@ -575,7 +575,9 @@ export const toDate = (self: DateTime.DateTime): Date => {
     Number(parts[3].value),
     Number(parts[4].value),
     Number(parts[5].value),
-    Number(parts[6].value)
+    parts[6]?.type === "fractionalSecond"
+      ? Number(parts[6].value)
+      : ((self.epochMilliseconds % 1000) + 1000) % 1000
   )
   self.adjustedEpochMilliseconds = date.getTime()
   return date