@akterjs/effect 0.0.0-stage → 0.1.0

package/src/host/blob/reference/blob-transfer-upkeep.pure.ts

@@ -0,0 +1,132 @@
+import { Array as Arr, Clock, Effect, Option, Ref } from "effect";
+
+import type { BlobClaim } from "./blob-catalog.sql.js";
+import type { BlobOwner, FileOperation, TransferEffect, TransferHome } from "./blob-transfer.pure.js";
+
+interface UpkeepHome extends TransferHome {
+  readonly run: FileOperation;
+  readonly uploads: Ref.Ref<Set<string>>;
+}
+
+interface TransferUpkeep {
+  readonly cancel: (owner: BlobOwner, claim: BlobClaim & { readonly receipt: string }) => TransferEffect<void>;
+  readonly collect: TransferEffect<readonly string[]>;
+  readonly erase: (owner: BlobOwner) => TransferEffect<void>;
+  readonly recover: (owner: BlobOwner) => TransferEffect<void>;
+  readonly settle: (owner: BlobOwner) => TransferEffect<void>;
+}
+
+const collectWith = ({ catalog, directory }: TransferHome): TransferUpkeep["collect"] =>
+  Effect.gen(function* collectUnreferenced() {
+    const deleting = yield* catalog.deletions;
+
+    yield* Effect.forEach(deleting, (blob) => Effect.andThen(directory.remove(blob), catalog.finishDelete(blob)), {
+      discard: true,
+    });
+
+    return deleting;
+  });
+
+const releaseWith = (home: TransferHome, owner: BlobOwner, claim: BlobClaim): TransferEffect<void> =>
+  Effect.andThen(home.catalog.release(claim), owner.transaction(owner.receipts.acknowledge(claim.claim)));
+
+const cancelWith = (
+  home: TransferHome,
+  owner: BlobOwner,
+  claim: BlobClaim & { readonly receipt: string },
+): TransferEffect<void> =>
+  Effect.gen(function* abandonUpload() {
+    yield* owner.transaction(owner.receipts.cancel(claim));
+    yield* releaseWith(home, owner, claim);
+  });
+
+const settleWith =
+  (home: TransferHome): TransferUpkeep["settle"] =>
+  (owner) =>
+    owner.exclusive(
+      Effect.gen(function* drainReleases() {
+        const erased = yield* owner.transaction(owner.receipts.erased);
+
+        if (erased) {
+          return yield* home.catalog.erase(owner.actor);
+        }
+
+        const now = yield* Clock.currentTimeMillis;
+
+        yield* owner.transaction(owner.receipts.expire(now));
+
+        const releases = yield* owner.transaction(owner.receipts.releases(now));
+
+        return yield* Effect.forEach(releases, (claim) => releaseWith(home, owner, claim), { discard: true });
+      }),
+    );
+
+const recoverClaim = (home: TransferHome, owner: BlobOwner, claim: BlobClaim): TransferEffect<void> =>
+  Effect.gen(function* reconcileUpload() {
+    const stored = yield* owner.transaction(owner.receipts.inspect(claim.claim));
+
+    if (Option.isSome(stored) && (stored.value.state === "prepared" || stored.value.state === "consumed")) {
+      return yield* home.catalog.complete(claim);
+    }
+
+    if (Option.isSome(stored)) {
+      return yield* cancelWith(home, owner, stored.value);
+    }
+
+    return yield* releaseWith(home, owner, claim);
+  });
+
+const recoverUploads = Effect.fnUntraced(function* recoverUploads(home: UpkeepHome, owner: BlobOwner) {
+  let after = "";
+
+  for (;;) {
+    const { active, claims } = yield* Effect.all({
+      active: Ref.get(home.uploads),
+      claims: home.catalog.pending(owner.actor, after),
+    });
+
+    if (!Arr.isReadonlyArrayNonEmpty(claims)) {
+      return;
+    }
+
+    const abandoned = Arr.filter(claims, (claim) => !active.has(claim.claim));
+
+    yield* Effect.forEach(abandoned, (claim) => recoverClaim(home, owner, claim), { discard: true });
+
+    after = Arr.lastNonEmpty(claims).claim;
+  }
+});
+
+const eraseWith = (home: TransferHome, owner: BlobOwner): TransferEffect<void> =>
+  owner.exclusive(Effect.andThen(owner.transaction(owner.receipts.erase), home.catalog.erase(owner.actor)));
+
+const transferUpkeep = (home: UpkeepHome): TransferUpkeep => ({
+  cancel: (owner, claim) => owner.exclusive(cancelWith(home, owner, claim)),
+  collect: collectWith(home),
+  erase: (owner) => eraseWith(home, owner),
+  recover: (owner) =>
+    owner.exclusive(
+      Effect.gen(function* recoverOwner() {
+        const erased = yield* owner.transaction(owner.receipts.erased);
+
+        if (erased) {
+          return yield* home.catalog.erase(owner.actor);
+        }
+
+        const incompleteFork = yield* owner.transaction(owner.forks.pending);
+
+        if (incompleteFork) {
+          yield* owner.transaction(owner.receipts.erase);
+
+          return yield* home.catalog.erase(owner.actor);
+        }
+
+        return yield* recoverUploads(home, owner);
+      }),
+    ),
+  settle: settleWith(home),
+});
+
+export { transferUpkeep };
+
+export type { TransferUpkeep };

package/src/host/blob/reference/blob-transfer.pure.ts

@@ -0,0 +1,127 @@
+import type { Effect, Stream } from "effect";
+import type { SqlError } from "effect/sql";
+
+import type { BlobRange, Opening, SealedBlob } from "#src/host/blob/blob-sealing.contract";
+import type { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import type { BlobDirectory } from "#src/host/blob/stream/blob-directory.pure";
+import type { BlobCatalog, BlobClaim } from "./blob-catalog.sql.js";
+import type { BlobForks } from "./blob-forks.sql.js";
+import type { BlobReceipts } from "./blob-receipts.sql.js";
+
+type TransferEffect<Value, Needs = never> = Effect.Effect<Value, BlobTransferError | SqlError.SqlError, Needs>;
+
+type Serialized = <Success, Failure, Needs>(
+  effect: Effect.Effect<Success, Failure, Needs>,
+) => Effect.Effect<Success, Failure, Needs>;
+
+type FileOperation = <Success, Failure, Needs>(
+  effect: Effect.Effect<Success, Failure, Needs>,
+  protect?: Serialized,
+) => Effect.Effect<Success, Failure | BlobTransferError, Needs>;
+
+type DurableTransaction = <Success, Failure, Needs>(
+  effect: Effect.Effect<Success, Failure, Needs>,
+) => Effect.Effect<Success, Failure | SqlError.SqlError, Needs>;
+
+interface BlobOwner {
+  readonly actor: string;
+  readonly exclusive: Serialized;
+  readonly forks: BlobForks;
+  readonly receipts: BlobReceipts;
+  readonly snapshot: Serialized;
+  readonly transaction: DurableTransaction;
+}
+
+interface TransferHome {
+  readonly catalog: BlobCatalog;
+  readonly directory: BlobDirectory;
+  /** Where the home keeps its blobs, canonical, so two homes are the same home only when their roots are equal. */
+  readonly root: string;
+}
+
+/** The home a fork's target keeps its files in, with its own transfers. */
+interface ForkHome extends TransferHome {
+  readonly transfers: BlobTransfers;
+}
+
+interface Upload<Failure, Services> {
+  readonly owner: BlobOwner;
+  readonly source: Stream.Stream<Uint8Array, Failure, Services>;
+}
+
+interface Download {
+  readonly owner: BlobOwner;
+  readonly path: string;
+  readonly range?: BlobRange;
+}
+
+/**
+ * One actor's files forked into another's. The fork runs on the home `source` keeps its files in; `into` is the home
+ * `target` keeps its files in. Within one home each file gains a claim for the target and its grant is rewrapped,
+ * with no bytes copied. Into another home each blob is adopted there (`adopt`): its sealed bytes are copied unchanged
+ * under the same blob id, and the target claims it in that home.
+ */
+interface Fork {
+  readonly into: ForkHome;
+  readonly operation: string;
+  readonly source: BlobOwner;
+  readonly target: BlobOwner;
+}
+
+/** A file as the home it comes from records it: its size and SHA-256, and its grant for the origin. */
+type AdoptedFile = Pick<SealedBlob, "bytes" | "grant" | "sha256">;
+
+/**
+ * A blob another home stores, taken into this one: `claim` names the actor that will hold it here, the blob's id
+ * unchanged, since sealed frames are bound to it, and the claim to hold it by. `stored` is its bytes in this home's
+ * at-rest form, read only when this home lacks the blob.
+ */
+interface Adoption<Failure, Services> {
+  readonly claim: BlobClaim;
+  readonly file: AdoptedFile;
+  /** The actor `file.grant` is wrapped for. */
+  readonly origin: string;
+  readonly stored: Stream.Stream<Uint8Array, Failure, Services>;
+}
+
+interface BlobTransfers {
+  readonly admit: Serialized;
+  /** Takes a blob into this home under `adoption.claim` and answers its grant for that actor (`blob-transfer-adopt`). */
+  readonly adopt: <Failure, Services>(
+    adoption: Adoption<Failure, Services>,
+  ) => Effect.Effect<string, BlobTransferError | SqlError.SqlError | Failure, Services>;
+  readonly close: Effect.Effect<void>;
+  readonly collect: TransferEffect<readonly string[]>;
+  readonly download: (download: Download) => Stream.Stream<Uint8Array, BlobTransferError | SqlError.SqlError>;
+  readonly erase: (owner: BlobOwner) => TransferEffect<void>;
+  readonly fork: (fork: Fork) => TransferEffect<void>;
+  /**
+   * Runs `effect` while no command, upload or other file operation of this home runs, so the home's blobs and catalog
+   * stay as they are; the fiber running it may still take any actor's own lock. A snapshot copies the home under it.
+   */
+  readonly hold: Serialized;
+  readonly open: (
+    opening: Omit<Opening, "filename">,
+  ) => Stream.Stream<Uint8Array, BlobTransferError | SqlError.SqlError>;
+  readonly recover: (owner: BlobOwner) => TransferEffect<void>;
+  readonly settle: (owner: BlobOwner) => TransferEffect<void>;
+  readonly upload: <Failure, Services>(
+    upload: Upload<Failure, Services>,
+  ) => Effect.Effect<string, BlobTransferError | SqlError.SqlError | Failure, Services>;
+}
+
+export type {
+  AdoptedFile,
+  Adoption,
+  BlobOwner,
+  BlobTransfers,
+  Download,
+  DurableTransaction,
+  FileOperation,
+  Fork,
+  ForkHome,
+  Serialized,
+  TransferEffect,
+  TransferHome,
+  Upload,
+};

package/src/host/blob/sealed-blob-sealing.pure.ts

@@ -0,0 +1,163 @@
+import { Effect, FileSystem, Stream } from "effect";
+import { Aead, SecureRandom } from "effect/crypto";
+
+import type { BlobHashing } from "#src/host/hash/blob-hashing.service";
+
+import { framesOf } from "./blob-frames.pure.js";
+import type { BlobGrants } from "./blob-grants.service.js";
+import { rangeOf } from "./blob-range.pure.js";
+import type { BlobRange, BlobSealingOperations, Opening } from "./blob-sealing.contract.js";
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import { blobWriter } from "./stream/blob-writing.pure.js";
+import { exactLength } from "./stream/blob-length.pure.js";
+
+interface FrameKeys {
+  readonly aead: Aead.Aead["Service"];
+  readonly blob: string;
+  readonly key: Aead.Key;
+  readonly random: SecureRandom.SecureRandom["Service"];
+}
+
+interface Frame extends FrameKeys {
+  readonly bytes: Uint8Array;
+  readonly index: number;
+}
+
+interface Selecting {
+  readonly bytes: Uint8Array;
+  readonly index: number;
+  readonly range: BlobRange;
+}
+
+const zeroBytes = 0;
+
+const oneFrame = 1;
+
+const frameBytes = 65_536;
+
+const nonceBytes = 24;
+
+const tagBytes = 16;
+
+const overhead = nonceBytes + tagBytes;
+
+const stride = frameBytes + overhead;
+
+const failed = (blob: string): BlobTransferError =>
+  BlobTransferError.make({ blob, message: "the sealed file could not be opened" });
+
+const bindingOf = (blob: string, index: number, final: boolean): Uint8Array =>
+  new globalThis.TextEncoder().encode(`akter/blob-frame/v1/${blob.length}:${blob}/${index}/${final}`);
+
+const encrypt = Effect.fnUntraced(function* encrypt({ aead, blob, bytes, index, key, random }: Frame) {
+  const nonce = yield* random.randomBytes(nonceBytes);
+  const aad = bindingOf(blob, index, bytes.byteLength < frameBytes);
+  const ciphertext = yield* aead.encrypt(key, bytes, { aad, nonce });
+  const stored = new Uint8Array(nonceBytes + ciphertext.byteLength);
+
+  stored.set(nonce);
+  stored.set(ciphertext, nonceBytes);
+
+  return stored;
+});
+
+const decrypt = Effect.fnUntraced(function* decrypt({ aead, blob, bytes, index, key }: Frame) {
+  const nonce = bytes.subarray(zeroBytes, nonceBytes);
+  const aad = bindingOf(blob, index, bytes.byteLength < stride);
+
+  return yield* aead.decrypt(key, bytes.subarray(nonceBytes), { aad, nonce });
+});
+
+const selected = ({ bytes, index, range }: Selecting): Uint8Array => {
+  const start = Math.max(zeroBytes, range.offset - index * frameBytes);
+  const end = Math.max(zeroBytes, Math.min(bytes.byteLength, range.offset + range.length - index * frameBytes));
+
+  return bytes.subarray(start, end);
+};
+
+const plaintextSize = (blob: string, physical: number): Effect.Effect<number, BlobTransferError> => {
+  const remainder = (physical - overhead) % stride;
+
+  if (physical < overhead || remainder >= frameBytes) {
+    return Effect.fail(failed(blob));
+  }
+
+  return Effect.succeed(Math.floor((physical - overhead) / stride) * frameBytes + remainder);
+};
+
+const openingWith =
+  (
+    fileSystem: FileSystem.FileSystem,
+    grants: BlobGrants["Service"],
+    keys: Omit<FrameKeys, "blob" | "key">,
+  ): BlobSealingOperations["open"] =>
+  (request: Opening) =>
+    Stream.unwrap(
+      Effect.gen(function* open() {
+        const key = yield* grants.open(request);
+        const stored = yield* Effect.mapError(fileSystem.stat(request.filename), () => failed(request.blob));
+        const bytes = yield* plaintextSize(request.blob, Number(stored.size));
+        const range = yield* rangeOf({ ...request, bytes });
+        const first = Math.floor(range.offset / frameBytes);
+        const last = Math.floor((range.offset + range.length) / frameBytes);
+        const offset = first * stride;
+        const end = Math.min((last + oneFrame) * stride, Number(stored.size));
+
+        const source = exactLength({
+          blob: request.blob,
+          bytes: end - offset,
+          source: fileSystem.stream(request.filename, { bytesToRead: end - offset, offset }),
+        });
+
+        return framesOf({ size: stride, source }).pipe(
+          Stream.filter((frame) => frame.byteLength > zeroBytes),
+          Stream.mapEffect((frame, index) =>
+            Effect.map(decrypt({ ...keys, blob: request.blob, bytes: frame, index: first + index, key }), (opened) =>
+              selected({ bytes: opened, index: first + index, range }),
+            ),
+          ),
+          Stream.mapError(() => failed(request.blob)),
+        );
+      }),
+    );
+
+const sealedBlobSealing = ({
+  grants,
+  hashing,
+}: {
+  readonly grants: BlobGrants["Service"];
+  readonly hashing: BlobHashing["Service"];
+}): Effect.Effect<BlobSealingOperations, never, FileSystem.FileSystem | Aead.Aead | SecureRandom.SecureRandom> =>
+  Effect.gen(function* makeSealedSealing() {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const write = yield* blobWriter;
+    const aead = yield* Aead.Aead;
+    const random = yield* SecureRandom.SecureRandom;
+
+    const seal: BlobSealingOperations["seal"] = Effect.fnUntraced(function* seal(request) {
+      const { grant, key } = yield* grants.fresh(request);
+      const hash = yield* hashing.sha256;
+      let bytes = zeroBytes;
+
+      const frameSource = Effect.fnUntraced(function* frameSource(frame: Uint8Array, index: number) {
+        yield* hash.update(frame);
+        bytes += frame.byteLength;
+
+        return yield* Effect.mapError(encrypt({ aead, blob: request.blob, bytes: frame, index, key, random }), () =>
+          failed(request.blob),
+        );
+      });
+
+      const source = framesOf({ size: frameBytes, source: request.source }).pipe(Stream.mapEffect(frameSource));
+
+      yield* write({ ...request, source });
+
+      const sha256 = yield* hash.digest;
+
+      return { bytes, grant, sha256 };
+    });
+
+    return { open: openingWith(fileSystem, grants, { aead, random }), rewrap: grants.rewrap, seal };
+  });
+
+export { sealedBlobSealing };

package/src/host/blob/stream/blob-directory.pure.ts

@@ -0,0 +1,177 @@
+import { Effect, Exit, FileSystem, Path, Schema, Stream } from "effect";
+
+import type { Opening, SealedBlob, Sealing } from "#src/host/blob/blob-sealing.contract";
+import type { BlobSealing } from "#src/host/blob/blob-sealing.service";
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+import { blobWriter } from "./blob-writing.pure.js";
+import type { WriteBlob } from "./blob-writing.pure.js";
+
+interface BlobDirectory {
+  readonly open: (opening: Omit<Opening, "filename">) => Stream.Stream<Uint8Array, BlobTransferError>;
+  /** Writes `source` as the blob's stored bytes, unchanged, replacing a partial file an interrupted write left. */
+  readonly place: <Failure, Services>(
+    placing: Pick<Sealing<Failure, Services>, "blob" | "source">,
+  ) => Effect.Effect<void, BlobTransferError | Failure, Services>;
+  readonly publish: <Failure, Services>(
+    sealing: Omit<Sealing<Failure, Services>, "filename">,
+  ) => Effect.Effect<SealedBlob, BlobTransferError | Failure, Services>;
+  readonly remove: (blob: string) => Effect.Effect<void, BlobTransferError>;
+  /** The blob's bytes as this home stores them, sealed or not, for another home to place unchanged. */
+  readonly stored: (blob: string) => Stream.Stream<Uint8Array, BlobTransferError>;
+}
+
+interface Directory {
+  readonly fileSystem: FileSystem.FileSystem;
+  readonly path: Path.Path;
+  readonly root: string;
+}
+
+const failed = (blob: string, message: string): BlobTransferError => BlobTransferError.make({ blob, message });
+
+const blobId = Schema.String.check(Schema.isUUID());
+
+const syncDirectory = (directory: Directory): Effect.Effect<void, BlobTransferError> =>
+  directory.fileSystem.open(directory.root, { flag: "r" }).pipe(
+    Effect.flatMap((opened) => opened.sync),
+    Effect.scoped,
+    Effect.mapError(() => failed("", "the blob directory could not be synced")),
+  );
+
+const filenameOf = (directory: Directory, blob: string): Effect.Effect<string, BlobTransferError> =>
+  Schema.decodeEffect(blobId)(blob).pipe(
+    Effect.mapBoth({
+      onFailure: () => failed(blob, "a blob id must be an opaque UUID"),
+      onSuccess: (valid) => directory.path.join(directory.root, valid),
+    }),
+  );
+
+const openingFilename = (directory: Directory, blob: string): Effect.Effect<string, BlobTransferError> =>
+  Effect.gen(function* resolveBlob() {
+    const filename = yield* filenameOf(directory, blob);
+
+    const actual = yield* Effect.mapError(directory.fileSystem.realPath(filename), () =>
+      failed(blob, "the blob could not be resolved"),
+    );
+
+    if (actual !== filename) {
+      return yield* failed(blob, "the blob must not redirect outside its location");
+    }
+
+    return filename;
+  });
+
+const prepareDirectory = Effect.fnUntraced(function* prepareDirectory(directory: Directory) {
+  yield* Effect.mapError(directory.fileSystem.makeDirectory(directory.root, { recursive: true }), () =>
+    failed("", "the blob directory could not be created"),
+  );
+
+  const actual = yield* Effect.mapError(directory.fileSystem.realPath(directory.root), () =>
+    failed("", "the blob directory could not be resolved"),
+  );
+
+  if (actual !== directory.root) {
+    return yield* failed("", "the blob directory must not redirect outside the store");
+  }
+
+  yield* syncDirectory({ ...directory, root: directory.path.dirname(directory.root) });
+
+  return yield* syncDirectory(directory);
+});
+
+const removeBlob = (directory: Directory, blob: string): Effect.Effect<void, BlobTransferError> =>
+  Effect.gen(function* removeBlobFile() {
+    const filename = yield* filenameOf(directory, blob);
+
+    yield* Effect.mapError(directory.fileSystem.remove(filename, { force: true }), () =>
+      failed(blob, "the blob could not be removed"),
+    );
+    yield* syncDirectory(directory);
+  });
+
+/** Syncs the directory after a blob's file was written, removing the file when the sync fails. */
+const syncedOrRemoved = (directory: Directory, blob: string): Effect.Effect<void, BlobTransferError> =>
+  syncDirectory(directory).pipe(
+    Effect.onExit((exit) => {
+      if (Exit.isSuccess(exit)) {
+        return Effect.void;
+      }
+
+      return removeBlob(directory, blob);
+    }),
+  );
+
+const publishWith = (directory: Directory, sealing: BlobSealing["Service"]): BlobDirectory["publish"] =>
+  Effect.fnUntraced(function* publish<Failure, Services>(
+    request: Omit<Sealing<Failure, Services>, "filename">,
+  ): Effect.fn.Return<SealedBlob, BlobTransferError | Failure, Services> {
+    const filename = yield* filenameOf(directory, request.blob);
+    const sealed = yield* sealing.seal({ ...request, filename });
+
+    yield* syncedOrRemoved(directory, request.blob);
+
+    return sealed;
+  });
+
+const placeWith = (directory: Directory, write: WriteBlob): BlobDirectory["place"] =>
+  Effect.fnUntraced(function* place<Failure, Services>({
+    blob,
+    source,
+  }: Pick<Sealing<Failure, Services>, "blob" | "source">): Effect.fn.Return<
+    void,
+    BlobTransferError | Failure,
+    Services
+  > {
+    const filename = yield* filenameOf(directory, blob);
+
+    yield* Effect.mapError(directory.fileSystem.remove(filename, { force: true }), () =>
+      failed(blob, "the leftover blob could not be removed"),
+    );
+    yield* write({ blob, filename, source });
+
+    return yield* syncedOrRemoved(directory, blob);
+  });
+
+const storedWith =
+  (directory: Directory): BlobDirectory["stored"] =>
+  (blob) => {
+    const read = (filename: string): Stream.Stream<Uint8Array, BlobTransferError> =>
+      Stream.mapError(directory.fileSystem.stream(filename), () => failed(blob, "the stored blob could not be read"));
+
+    return Stream.unwrap(Effect.map(openingFilename(directory, blob), read));
+  };
+
+const blobDirectory = ({
+  store,
+  sealing,
+}: {
+  readonly store: string;
+  readonly sealing: BlobSealing["Service"];
+}): Effect.Effect<BlobDirectory, BlobTransferError, FileSystem.FileSystem | Path.Path> =>
+  Effect.gen(function* openBlobDirectory() {
+    const fileSystem = yield* FileSystem.FileSystem;
+    const path = yield* Path.Path;
+
+    const parent = yield* Effect.mapError(fileSystem.realPath(store), () =>
+      failed("", "the store could not be resolved"),
+    );
+
+    const directory: Directory = { fileSystem, path, root: path.join(parent, "blobs") };
+    const write = yield* blobWriter;
+
+    yield* prepareDirectory(directory);
+
+    return {
+      open: (opening) =>
+        Stream.unwrap(
+          Effect.map(openingFilename(directory, opening.blob), (filename) => sealing.open({ ...opening, filename })),
+        ),
+      place: placeWith(directory, write),
+      publish: publishWith(directory, sealing),
+      remove: (blob) => removeBlob(directory, blob),
+      stored: storedWith(directory),
+    };
+  });
+
+export { blobDirectory };
+
+export type { BlobDirectory };

package/src/host/blob/stream/blob-length.pure.ts

@@ -0,0 +1,40 @@
+import { Effect, Stream } from "effect";
+
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+
+interface Reading<Failure, Services> {
+  readonly blob: string;
+  readonly bytes: number;
+  readonly source: Stream.Stream<Uint8Array, Failure, Services>;
+}
+
+const zeroBytes = 0;
+
+const exactLength = <Failure, Services>({
+  blob,
+  bytes,
+  source,
+}: Reading<Failure, Services>): Stream.Stream<Uint8Array, Failure | BlobTransferError, Services> =>
+  Stream.suspend(() => {
+    let read = zeroBytes;
+
+    const counted = Stream.tap(source, (chunk) =>
+      Effect.sync(() => {
+        read += chunk.byteLength;
+      }),
+    );
+
+    const finished = Effect.suspend(() => {
+      if (read !== bytes) {
+        return Effect.fail(
+          BlobTransferError.make({ blob, message: "the file ended before the requested bytes were read" }),
+        );
+      }
+
+      return Effect.void;
+    });
+
+    return Stream.concat(counted, Stream.drain(Stream.fromEffect(finished)));
+  });
+
+export { exactLength };

package/src/host/blob/stream/blob-writing.pure.ts

@@ -0,0 +1,49 @@
+import { Effect, Exit, FileSystem, Stream } from "effect";
+import type { Scope } from "effect";
+
+import type { Sealing } from "#src/host/blob/blob-sealing.contract";
+import { BlobTransferError } from "#src/contract/file/blob-transfer.errors";
+
+/** What a blob write needs: the bytes and where they go. Placing bytes as they are needs no actor. */
+type BlobWrite<Failure, Services> = Pick<Sealing<Failure, Services>, "blob" | "filename" | "source">;
+
+type WriteBlob = <Failure, Services>(
+  sealing: BlobWrite<Failure, Services>,
+) => Effect.Effect<void, BlobTransferError | Failure, Services>;
+
+const failed = (blob: string, message: string): BlobTransferError => BlobTransferError.make({ blob, message });
+
+const blobWriter: Effect.Effect<WriteBlob, never, FileSystem.FileSystem> = Effect.map(
+  FileSystem.FileSystem,
+  (fileSystem) =>
+    Effect.fnUntraced(function* writeBlob<Failure, Services>({
+      blob,
+      filename,
+      source,
+    }: BlobWrite<Failure, Services>): Effect.fn.Return<void, BlobTransferError | Failure, Services | Scope.Scope> {
+      const file = yield* Effect.mapError(fileSystem.open(filename, { flag: "wx" }), () =>
+        failed(blob, "the upload destination could not be opened"),
+      );
+
+      const written = Stream.runForEach(source, (bytes) =>
+        Effect.mapError(file.writeAll(bytes), () => failed(blob, "the upload could not be written")),
+      );
+
+      yield* written.pipe(
+        Effect.andThen(Effect.mapError(file.sync, () => failed(blob, "the upload could not be synced"))),
+        Effect.onExit((exit) => {
+          if (Exit.isSuccess(exit)) {
+            return Effect.void;
+          }
+
+          return Effect.mapError(fileSystem.remove(filename, { force: true }), () =>
+            failed(blob, "the incomplete upload could not be removed"),
+          );
+        }),
+      );
+    }, Effect.scoped),
+);
+
+export { blobWriter };
+
+export type { WriteBlob };