hyperbrane 0.1.1 → 0.2.0

package/dist/lib/docker.d.ts

@@ -1,6 +1,5 @@
 import type { components, operations } from "./docker-api.ts";
 import type { Sandbox } from "../sandbox/api.ts";
-/** Engine API version the client speaks. After changing it, run `bun run generate:docker-api`. */
 export declare const DOCKER_API_VERSION = "v1.44";
 type Schemas = components["schemas"];
 export type ContainerInspect = operations["ContainerInspect"]["responses"][200]["content"]["application/json"];
@@ -11,16 +10,13 @@ export type ImageSummary = Schemas["ImageSummary"];
 export type DockerEvent = Schemas["EventMessage"];
 export type ContainerResources = Pick<Schemas["Resources"], "Memory" | "MemorySwap" | "NanoCpus">;
 export type ContainerStats = {
-    /** Bytes, excluding reclaimable page cache (same number `docker stats` shows). */
     memoryUsage: number;
-    /** Cores in use, e.g. 0.25 = a quarter of one core. */
     cpuUsage: number;
 };
 export type ExecOptions = {
     cmd: string[];
     user?: string;
     env?: Record<string, string>;
-    /** Defaults to the container's working directory. */
     workdir?: string;
 };
 export type ExecResult = {
@@ -30,7 +26,6 @@ export type ExecResult = {
 };
 export type BuildOptions = {
     tag: string;
-    /** Build context: file path inside the context -> file contents. Must include "Dockerfile". */
     context: Record<string, string>;
     labels?: Record<string, string>;
 };
@@ -38,41 +33,24 @@ export type BuildOptions = {
 export interface DockerClient {
     imageExists(image: string): Promise<boolean>;
     buildImage(options: BuildOptions): Promise<void>;
-    /** Filters use docker's syntax, e.g. { label: ["hyperbrane"], reference: ["hyperbrane-dimension"] }. */
     listImages(filters: Record<string, string[]>): Promise<ImageSummary[]>;
-    /** Removes a tag (and the image, once untagged). No-op if missing; DockerError 409 while a container uses it. */
     removeImage(image: string): Promise<void>;
     inspectContainer(name: string): Promise<ContainerInspect | null>;
     listContainers(label: string): Promise<ContainerSummary[]>;
-    /** Throws DockerError with status 409 if a container with this name already exists. */
     createContainer(name: string, spec: ContainerCreateSpec): Promise<void>;
-    /** No-op if the container is already running. */
     startContainer(name: string): Promise<void>;
-    /** No-op if the container is already stopped. */
     stopContainer(name: string): Promise<void>;
-    /** Stops the container (if running) and starts it again. */
     restartContainer(name: string): Promise<void>;
-    /** Force-removes the container and its anonymous volumes. No-op if it doesn't exist. */
     removeContainer(name: string): Promise<void>;
     containerStats(name: string): Promise<ContainerStats>;
-    /** Changes a container's resource limits in place: no restart. */
     updateContainer(name: string, resources: ContainerResources): Promise<void>;
     exec(name: string, options: ExecOptions): Promise<ExecResult>;
-    /**
-     * Extracts `files` (path relative to `directory` -> contents) into the container, owned by root.
-     * `directory` must exist. DockerError 404 if the container or the directory doesn't.
-     */
     putArchive(name: string, directory: string, files: Record<string, string | Uint8Array>): Promise<void>;
-    /**
-     * Streams events as they happen, e.g. filters { type: ["container"], event: ["start"] }. Ends when
-     * `signal` aborts (quietly) or the daemon drops the connection.
-     */
     events(filters: Record<string, string[]>, signal: AbortSignal): AsyncIterable<DockerEvent>;
 }
 export declare class DockerError extends Error {
     readonly status: number;
     constructor(status: number, message: string);
 }
-/** Talks to the docker daemon whose API socket is at `socketPath` inside `sandbox`. */
 export declare function createDockerClient(sandbox: Sandbox, socketPath?: string): DockerClient;
 export {};

package/dist/lib/docker.js

@@ -1,6 +1,5 @@
 import createClient from "openapi-fetch";
 import { createTar } from "./tar.js";
-/** Engine API version the client speaks. After changing it, run `bun run generate:docker-api`. */
 export const DOCKER_API_VERSION = "v1.44";
 export class DockerError extends Error {
     status;
@@ -10,14 +9,12 @@ export class DockerError extends Error {
         this.name = "DockerError";
     }
 }
-/** Returns the data of a successful call (or of one whose status is listed in `allowed`), else throws DockerError. */
 function unwrap({ data, error, response }, allowed = []) {
     if (response.ok || allowed.includes(response.status))
         return data;
     const message = error?.message ?? response.statusText;
     throw new DockerError(response.status, message);
 }
-/** Talks to the docker daemon whose API socket is at `socketPath` inside `sandbox`. */
 export function createDockerClient(sandbox, socketPath = "/var/run/docker.sock") {
     function sandboxFetch(timeout) {
         return async (request) => sandbox.fetch(request.url, {
@@ -40,12 +37,10 @@ export function createDockerClient(sandbox, socketPath = "/var/run/docker.sock")
         const result = await api.POST("/build", {
             params: { query: { t: tag, labels: JSON.stringify(labels), rm: true, forcerm: true } },
             headers: { "Content-type": "application/x-tar" },
-            // The spec models the binary tar stream as a string.
             body: tar,
             bodySerializer: (body) => body,
             parseAs: "text",
         });
-        // The build streams JSON lines; failures arrive in-band with HTTP 200.
         const log = [];
         for (const line of (unwrap(result) ?? "").split("\n").filter(Boolean)) {
             const event = JSON.parse(line);
@@ -93,7 +88,6 @@ export function createDockerClient(sandbox, socketPath = "/var/run/docker.sock")
         unwrap(await api.POST("/containers/{id}/update", { params: { path: { id: name } }, body: resources }));
     }
     async function containerStats(name) {
-        // stream=false without one-shot waits for two samples, which the CPU delta needs.
         const result = await api.GET("/containers/{id}/stats", {
             params: { path: { id: name }, query: { stream: false } },
         });
@@ -126,7 +120,6 @@ export function createDockerClient(sandbox, socketPath = "/var/run/docker.sock")
         const result = await api.PUT("/containers/{id}/archive", {
             params: { path: { id: name }, query: { path: directory } },
             headers: { "Content-type": "application/x-tar" },
-            // The spec models the binary tar stream as a string.
             body: tar,
             bodySerializer: (body) => body,
             parseAs: "text",
@@ -139,13 +132,11 @@ export function createDockerClient(sandbox, socketPath = "/var/run/docker.sock")
                 params: { query: { filters: JSON.stringify(filters) } },
                 parseAs: "stream",
                 signal,
-                // The stream stays silent while nothing happens; an idle timeout would cut it.
                 fetch: sandboxFetch(false),
             });
             const body = unwrap(result);
             if (!body)
                 return;
-            // One JSON object per line.
             const decoder = new TextDecoder();
             let buffered = "";
             for await (const chunk of body) {
@@ -193,7 +184,6 @@ function toContainerStats(raw) {
     const cpuUsage = systemDelta > 0 && cpuDelta > 0 ? (cpuDelta / systemDelta) * cpus : 0;
     return { memoryUsage, cpuUsage };
 }
-/** Splits docker's multiplexed attach stream: 8-byte header (stream id, 3 pad, uint32 BE size) per frame. */
 function demuxStream(bytes) {
     const decoder = new TextDecoder();
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);

package/dist/lib/image.d.ts

@@ -1,14 +1,11 @@
 import { type DockerClient } from "./docker.ts";
 export type ImageSpec = {
     repository: string;
-    /** Bump whenever the build context changes; the tag is how an existing build is recognised. */
     version: string;
-    /** Build context: file path -> contents. Must include "Dockerfile". */
     context: Record<string, string>;
 };
 export interface ManagedImage {
     readonly tag: string;
-    /** Builds the image if it isn't present yet, removes outdated versions, and returns its tag. */
     ensure(): Promise<string>;
 }
 export declare function createManagedImage(docker: DockerClient, { repository, version, context }: ImageSpec): ManagedImage;

package/dist/lib/image.js

@@ -1,7 +1,6 @@
 import { DockerError } from "./docker.js";
 export function createManagedImage(docker, { repository, version, context }) {
     const tag = `${repository}:${version}`;
-    // Concurrent builds of the same tag (from any process) are harmless: they produce the same image.
     async function ensure() {
         if (!(await docker.imageExists(tag))) {
             await docker.buildImage({ tag, context, labels: { hyperbrane: "true", "hyperbrane.image.version": version } });
@@ -9,7 +8,6 @@ export function createManagedImage(docker, { repository, version, context }) {
         await removeOutdatedImages().catch((error) => console.warn(`removing outdated ${repository} images failed:`, error));
         return tag;
     }
-    // Images still used by a container are skipped (docker answers 409) and retried on a later ensure().
     async function removeOutdatedImages() {
         const images = await docker.listImages({ label: ["hyperbrane"], reference: [repository] });
         const outdated = images

package/dist/lib/jsonDirectory.d.ts

@@ -1,28 +1,15 @@
 import { type Sandbox } from "../sandbox/api.ts";
-/**
- * One JSON file per record in a sandbox directory, so no operation rewrites a shared file and every
- * write is a single atomic sandbox operation. Safe to use from several processes at once.
- */
 export interface JsonDirectory<T> {
-    /** Null if missing. */
     read(name: string): Promise<T | null>;
-    /** Stores the record unless one with that name exists; returns whichever record is stored afterwards. */
     insert(name: string, record: T): Promise<T>;
-    /** Replaces the record. */
     save(name: string, record: T): Promise<void>;
-    /** No-op if missing. */
     remove(name: string): Promise<void>;
-    /** Empty if the directory doesn't exist yet. */
     list(): Promise<T[]>;
-    /** list, each record with its name. */
     entries(): Promise<[string, T][]>;
 }
 export declare class InvalidNameError extends Error {
     name: string;
 }
-/** Throws InvalidNameError unless `name` is safe to use as a path segment. */
 export declare function checkName(name: string): string;
-/** `dir` resolves to a sandbox path; it's re-resolved per call so it can depend on the sandbox's home. */
 export declare function createJsonDirectory<T>(sandbox: Sandbox, dir: () => Promise<string>): JsonDirectory<T>;
-/** ~/.local/share/hyperbrane of the sandbox's user. */
 export declare function defaultDataDir(sandbox: Sandbox): Promise<string>;

package/dist/lib/jsonDirectory.js

@@ -1,18 +1,16 @@
 import { SandboxNotFoundError } from "../sandbox/api.js";
+import { sh } from "./sh.js";
 const EXTENSION = ".json";
-// Same alphabet as dimension names; keeps names safe to use as file and directory names.
 const NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,62}$/;
 export class InvalidNameError extends Error {
     name = "InvalidNameError";
 }
-/** Throws InvalidNameError unless `name` is safe to use as a path segment. */
 export function checkName(name) {
     if (!NAME_PATTERN.test(name)) {
         throw new InvalidNameError(`Invalid name "${name}": use letters, digits, "_", "." and "-", up to 63 characters`);
     }
     return name;
 }
-/** `dir` resolves to a sandbox path; it's re-resolved per call so it can depend on the sandbox's home. */
 export function createJsonDirectory(sandbox, dir) {
     async function pathFor(name) {
         return `${await dir()}/${checkName(name)}${EXTENSION}`;
@@ -37,7 +35,6 @@ export function createJsonDirectory(sandbox, dir) {
         const path = await pathFor(name);
         if (await sandbox.writeFileExclusive(path, serialize(record)))
             return record;
-        // Lost to an existing record; if that one was removed in the meantime, try again.
         return (await readPath(path)) ?? insert(name, record);
     }
     async function save(name, record) {
@@ -46,11 +43,9 @@ export function createJsonDirectory(sandbox, dir) {
     async function remove(name) {
         await sandbox.removeFile(await pathFor(name));
     }
-    // One command for the whole directory: over SSH or Boat, a call per record adds up. Falls back to
-    // listing and reading where the command can't run.
     async function entries() {
         const path = await dir();
-        const all = await sandbox.runCommand(["sh", "-c", LIST_SCRIPT, "sh", path]).catch(() => null);
+        const all = await sandbox.runCommand(["sh", "-c", LIST_SCRIPT, "sh", path], { env: { MISSING: String(MISSING), EXTENSION } }).catch(() => null);
         if (all?.exitCode === MISSING)
             return [];
         if (all?.exitCode === 0) {
@@ -76,7 +71,6 @@ export function createJsonDirectory(sandbox, dir) {
                 return [];
             throw error;
         }
-        // A record removed between listing and reading is simply skipped.
         const records = await Promise.all(files
             .filter((file) => file.endsWith(EXTENSION))
             .map(async (file) => [file.slice(0, -EXTENSION.length), await readPath(`${path}/${file}`)]));
@@ -87,16 +81,17 @@ export function createJsonDirectory(sandbox, dir) {
     }
     return { read, insert, save, remove, list, entries };
 }
-/** list's command exits with it when the directory doesn't exist. */
 const MISSING = 44;
-/** Ends each record list's command prints (its file name, a newline, its JSON): a record separator, which JSON escapes inside strings. */
 const RECORD_END = "\n\x1e\n";
-const LIST_SCRIPT = `cd "$1" 2>/dev/null || exit ${MISSING}
-for file in *${EXTENSION}; do
+const LIST_SCRIPT = sh `
+cd "$1" 2>/dev/null || exit "$MISSING"
+for file in *"$EXTENSION"; do
   [ -f "$file" ] || continue
-  printf '%s\\n' "$file" && cat "$file" && printf '\\n\\036\\n'
-done`;
-/** ~/.local/share/hyperbrane of the sandbox's user. */
+  printf '%s\n' "$file"
+  cat "$file"
+  printf '\n\036\n'
+done
+`;
 export async function defaultDataDir(sandbox) {
     return `${await sandbox.homeDirectory()}/.local/share/hyperbrane`;
 }

package/dist/lib/scriptBundle.d.ts

@@ -0,0 +1,6 @@
+export type ScriptBundle = {
+    source: string;
+    build: string;
+};
+export declare function scriptBundle(entry: () => string, generated: () => Promise<string>): () => Promise<ScriptBundle>;
+export declare function buildScript(entry: string): Promise<string>;

package/dist/lib/scriptBundle.js

@@ -0,0 +1,28 @@
+import { createHash } from "node:crypto";
+import { existsSync } from "node:fs";
+export function scriptBundle(entry, generated) {
+    let bundled;
+    async function load() {
+        const fromSources = "Bun" in globalThis && existsSync(entry());
+        const source = fromSources ? await buildScript(entry()) : await generated();
+        return { source, build: createHash("sha256").update(source).digest("hex").slice(0, 16) };
+    }
+    return () => {
+        bundled ??= load().catch((error) => {
+            bundled = undefined;
+            throw error;
+        });
+        return bundled;
+    };
+}
+export async function buildScript(entry) {
+    for (let attempt = 1;; attempt++) {
+        const result = await Bun.build({ entrypoints: [entry], target: "bun" }).catch((error) => error);
+        if (!(result instanceof Error))
+            return result.outputs[0].text();
+        const logs = (result.errors ?? [result]).map(String).join("\n");
+        if (attempt >= BUILD_ATTEMPTS || !/Could not resolve|Unseekable reading file/.test(logs))
+            throw new Error(`bundling ${entry} failed:\n${logs}`);
+    }
+}
+const BUILD_ATTEMPTS = 3;

package/dist/lib/sh.d.ts

@@ -0,0 +1,2 @@
+export declare function sh(strings: TemplateStringsArray, ...values: never[]): string;
+export declare function scriptText(raw: string): string;

package/dist/lib/sh.js

@@ -0,0 +1,8 @@
+export function sh(strings, ...values) {
+    if (values.length > 0)
+        throw new Error("sh`…` takes no interpolations: pass inputs as environment variables or arguments");
+    return scriptText(strings.raw[0]);
+}
+export function scriptText(raw) {
+    return raw.replace(/\\(\$\{|`)/g, "$1").replace(/^\n/, "");
+}

package/dist/lib/sleep.d.ts

@@ -1,2 +1 @@
-/** Resolves after `ms` milliseconds. Portable stand-in for Bun.sleep, so the services run under Node too. */
 export declare function sleep(ms: number): Promise<void>;

package/dist/lib/sleep.js

@@ -1,4 +1,3 @@
-/** Resolves after `ms` milliseconds. Portable stand-in for Bun.sleep, so the services run under Node too. */
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/lib/streamFetch.d.ts

@@ -0,0 +1,15 @@
+export type HttpStream = {
+    write(data: string | Uint8Array): unknown;
+    on(event: "data", listener: (chunk: Buffer) => void): unknown;
+    on(event: "error", listener: (error: Error) => void): unknown;
+    on(event: "end" | "close", listener: () => void): unknown;
+    destroy(): unknown;
+};
+export type StreamFetchInit = {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array;
+    signal?: AbortSignal;
+    timeout?: number | false;
+};
+export declare function fetchOverStream(stream: HttpStream, url: string, init: StreamFetchInit, where: string): Promise<Response>;

package/dist/lib/streamFetch.js

@@ -0,0 +1,150 @@
+export function fetchOverStream(stream, url, init, where) {
+    if (init.signal?.aborted) {
+        stream.destroy();
+        return Promise.reject(init.signal.reason);
+    }
+    const target = new URL(url);
+    const body = init.body === undefined ? undefined : typeof init.body === "string" ? Buffer.from(init.body) : Buffer.from(init.body);
+    const head = [`${init.method ?? "GET"} ${target.pathname}${target.search} HTTP/1.1`, `Host: ${target.host}`, "Connection: close"];
+    for (const [name, value] of Object.entries(init.headers ?? {}))
+        head.push(`${name}: ${value}`);
+    if (body)
+        head.push(`Content-Length: ${body.length}`);
+    stream.write(`${head.join("\r\n")}\r\n\r\n`);
+    if (body)
+        stream.write(body);
+    let idle;
+    let fail = () => { };
+    const touch = () => {
+        if (typeof init.timeout !== "number")
+            return;
+        clearTimeout(idle);
+        idle = setTimeout(() => fail(new Error(`fetch ${url} on ${where}: no data for ${init.timeout}ms`)), init.timeout);
+    };
+    const abort = () => fail(init.signal.reason instanceof Error ? init.signal.reason : new Error("aborted"));
+    init.signal?.addEventListener("abort", abort, { once: true });
+    const finish = () => {
+        clearTimeout(idle);
+        init.signal?.removeEventListener("abort", abort);
+        stream.destroy();
+    };
+    touch();
+    return new Promise((resolve, reject) => {
+        let buffer = Buffer.alloc(0);
+        let responded = false;
+        let controller = null;
+        let framing = { kind: "close" };
+        let done = false;
+        const end = () => {
+            if (done)
+                return;
+            done = true;
+            finish();
+            try {
+                controller?.close();
+            }
+            catch {
+            }
+        };
+        fail = (error) => {
+            if (done)
+                return;
+            done = true;
+            finish();
+            if (!responded)
+                reject(error);
+            else
+                controller?.error(error);
+        };
+        const pumpBody = () => {
+            if (framing.kind === "close") {
+                if (buffer.length)
+                    controller?.enqueue(new Uint8Array(buffer));
+                buffer = Buffer.alloc(0);
+                return false;
+            }
+            if (framing.kind === "length") {
+                const take = buffer.subarray(0, framing.left);
+                if (take.length)
+                    controller?.enqueue(new Uint8Array(take));
+                framing.left -= take.length;
+                buffer = buffer.subarray(take.length);
+                return framing.left === 0;
+            }
+            for (;;) {
+                const lineEnd = buffer.indexOf("\r\n");
+                if (lineEnd < 0)
+                    return false;
+                const size = parseInt(buffer.subarray(0, lineEnd).toString(), 16);
+                if (Number.isNaN(size))
+                    throw new Error("malformed chunked body");
+                if (size === 0)
+                    return true;
+                if (buffer.length < lineEnd + 2 + size + 2)
+                    return false;
+                controller?.enqueue(new Uint8Array(buffer.subarray(lineEnd + 2, lineEnd + 2 + size)));
+                buffer = buffer.subarray(lineEnd + 2 + size + 2);
+            }
+        };
+        const onData = (chunk) => {
+            if (done)
+                return;
+            touch();
+            buffer = buffer.length ? Buffer.concat([buffer, chunk]) : chunk;
+            try {
+                if (!responded) {
+                    const headEnd = buffer.indexOf("\r\n\r\n");
+                    if (headEnd < 0)
+                        return;
+                    const [statusLine = "", ...lines] = buffer.subarray(0, headEnd).toString("latin1").split("\r\n");
+                    buffer = buffer.subarray(headEnd + 4);
+                    const status = Number(statusLine.split(" ")[1]);
+                    if (status >= 100 && status < 200)
+                        return onData(Buffer.alloc(0));
+                    const headers = new Headers();
+                    for (const line of lines) {
+                        const colon = line.indexOf(":");
+                        if (colon > 0)
+                            headers.append(line.slice(0, colon).trim(), line.slice(colon + 1).trim());
+                    }
+                    responded = true;
+                    if (status === 204 || status === 304 || init.method === "HEAD") {
+                        resolve(new Response(null, { status, headers }));
+                        return end();
+                    }
+                    if (headers.get("transfer-encoding")?.toLowerCase().includes("chunked"))
+                        framing = { kind: "chunked" };
+                    else if (headers.has("content-length"))
+                        framing = { kind: "length", left: Number(headers.get("content-length")) };
+                    const responseBody = new ReadableStream({
+                        start(c) {
+                            controller = c;
+                        },
+                        cancel() {
+                            done = true;
+                            finish();
+                        },
+                    });
+                    resolve(new Response(responseBody, { status, headers }));
+                }
+                if (pumpBody())
+                    end();
+            }
+            catch (error) {
+                fail(error);
+            }
+        };
+        stream.on("data", onData);
+        stream.on("error", (error) => fail(new Error(`fetch ${url} on ${where} failed: ${error.message}`)));
+        const ended = () => {
+            if (!responded)
+                return fail(new Error(`fetch ${url} on ${where} failed: the socket closed before a response`));
+            if (framing.kind === "close")
+                end();
+            else
+                fail(new Error(`fetch ${url} on ${where} failed: the response was cut short`));
+        };
+        stream.on("end", ended);
+        stream.on("close", ended);
+    });
+}

package/dist/lib/tar.d.ts

@@ -1,2 +1 @@
-/** Packs `files` (path -> contents) into a tar archive. Files are mode 0644, owned by root. */
 export declare function createTar(files: Record<string, string | Uint8Array>): Uint8Array<ArrayBuffer>;

package/dist/lib/tar.js

@@ -1,9 +1,5 @@
-// A minimal tar (ustar) writer: regular files only, which is all a docker build context or
-// putArchive needs (docker creates missing parent directories). Portable stand-in for Bun.Archive,
-// so the services run under Node too.
 const BLOCK = 512;
 function octal(value, width) {
-    // width includes the trailing NUL.
     return value.toString(8).padStart(width - 1, "0") + "\0";
 }
 function header(name, size, mode, mtime) {
@@ -18,7 +14,6 @@ function header(name, size, mode, mtime) {
     let path = name;
     let prefix = "";
     if (encoder.encode(name).length > 100) {
-        // ustar splits long paths at a "/" into prefix (155) and name (100).
         const cut = name.lastIndexOf("/", 155);
         if (cut <= 0)
             throw new Error(`tar: "${name}" is too long`);
@@ -27,12 +22,12 @@ function header(name, size, mode, mtime) {
     }
     put(path, 0, 100);
     put(octal(mode, 8), 100, 8);
-    put(octal(0, 8), 108, 8); // uid
-    put(octal(0, 8), 116, 8); // gid
+    put(octal(0, 8), 108, 8);
+    put(octal(0, 8), 116, 8);
     put(octal(size, 12), 124, 12);
     put(octal(mtime, 12), 136, 12);
-    put("        ", 148, 8); // checksum placeholder: eight spaces while summing
-    put("0", 156, 1); // regular file
+    put("        ", 148, 8);
+    put("0", 156, 1);
     put("ustar\0", 257, 6);
     put("00", 263, 2);
     put(prefix, 345, 155);
@@ -42,7 +37,6 @@ function header(name, size, mode, mtime) {
     put(sum.toString(8).padStart(6, "0") + "\0 ", 148, 8);
     return block;
 }
-/** Packs `files` (path -> contents) into a tar archive. Files are mode 0644, owned by root. */
 export function createTar(files) {
     const encoder = new TextEncoder();
     const mtime = Math.floor(Date.now() / 1000);
@@ -54,7 +48,7 @@ export function createTar(files) {
         if (padding)
             parts.push(new Uint8Array(padding));
     }
-    parts.push(new Uint8Array(BLOCK * 2)); // end of archive
+    parts.push(new Uint8Array(BLOCK * 2));
     const out = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
     let offset = 0;
     for (const part of parts) {