@executablemd/runtime 0.8.1 → 0.9.1

package/esm/_dnt.polyfills.js

@@ -0,0 +1 @@
+export {};

package/esm/_dnt.shims.js

@@ -0,0 +1,57 @@
+const dntGlobals = {};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/agent-session-coordinator.js

@@ -0,0 +1,91 @@
+/**
+ * Exclusive ownership of one logical agent session
+ * (specs/native-agent-session-launch-spec.md §Ownership and concurrency).
+ *
+ * An advertised provider-returned session can be handed to a native UI, and a
+ * native UI is a live owner nothing on the XMD side can observe. So every
+ * operation that could act on such a session — establishing it, running a turn,
+ * launching into it — enters here first, and a host that cannot answer the
+ * ownership question refuses rather than guessing.
+ *
+ * This is a plain capability, injected directly by the host into the provider
+ * that needs it. It is deliberately not a contextual Api: ownership is a
+ * security decision, and a decision document middleware can replace is not one.
+ *
+ * Acquisition never waits. A native UI may stay open for hours, and a caller
+ * that queued would hold the reader's terminal while offering no way to reach
+ * the owner it waits for.
+ */
+import { createHash } from "node:crypto";
+/** Another live owner holds this session right now. */
+export class AgentSessionBusy extends Error {
+    name = "AgentSessionBusy";
+}
+/**
+ * The last owner never proved it stopped.
+ *
+ * A crash releases the kernel lock but not this: nothing observable afterwards
+ * distinguishes a session whose owner died mid-turn from one it left cleanly,
+ * so the conservative answer stands until someone recovers it deliberately.
+ */
+export class AgentSessionRecoveryRequired extends Error {
+    name = "AgentSessionRecoveryRequired";
+}
+/**
+ * The digest that names one session's sidecar and ownership record.
+ *
+ * Canonical, so every process derives the same name, and a digest, so the
+ * coordination namespace holds no agent name, session name, path or authored
+ * value.
+ */
+export function agentSessionKeyDigest(key) {
+    return createHash("sha256")
+        .update(JSON.stringify([key.provider, key.agent, key.sessionKey]), "utf8")
+        .digest("hex");
+}
+const OWNER_KINDS = ["session", "prompt", "native-launch"];
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Read an ownership record strictly.
+ *
+ * An unknown schema, a missing field, or a member this build cannot account for
+ * describes state it must not act on — so it is refused rather than read
+ * partially, and never repaired.
+ */
+export function parseAgentSessionOwnership(value) {
+    if (!isRecord(value) || value.schema !== "agent-session-ownership.v1") {
+        return undefined;
+    }
+    const allowed = ["schema", "keyDigest", "state", "ownerKind", "operationId"];
+    for (const member of Object.keys(value)) {
+        if (!allowed.includes(member)) {
+            return undefined;
+        }
+    }
+    const { keyDigest, state, operationId } = value;
+    if (typeof keyDigest !== "string" || !/^[0-9a-f]{64}$/.test(keyDigest)) {
+        return undefined;
+    }
+    if (state !== "active" && state !== "idle") {
+        return undefined;
+    }
+    if (typeof operationId !== "string" || operationId.length === 0) {
+        return undefined;
+    }
+    const ownerKind = OWNER_KINDS.find((kind) => kind === value.ownerKind);
+    if (!ownerKind) {
+        return undefined;
+    }
+    return { schema: "agent-session-ownership.v1", keyDigest, state, ownerKind, operationId };
+}
+export function serializeAgentSessionOwnership(record) {
+    return `${JSON.stringify({
+        schema: record.schema,
+        keyDigest: record.keyDigest,
+        state: record.state,
+        ownerKind: record.ownerKind,
+        operationId: record.operationId,
+    }, null, 2)}\n`;
+}

package/esm/apis.js

@@ -75,12 +75,39 @@ import { join } from "node:path";
 import process from "node:process";
 import { realpath as fsRealpath, rename as fsRename } from "node:fs/promises";
 import { fetch as effectionFetch } from "@effectionx/fetch";
-import { ensureDir as fsEnsureDir, FsApi, globToRegExp, readTextFile as fsReadTextFile, rm as fsRm, stat as fsStat, writeTextFile as fsWriteTextFile, } from "@effectionx/fs";
+import { ensureDir as fsEnsureDir, FsApi, globToRegExp, lstat as fsLstat, readTextFile as fsReadTextFile, rm as fsRm, stat as fsStat, writeTextFile as fsWriteTextFile, } from "@effectionx/fs";
 import { exec as processExec, Stdio } from "@effectionx/process";
 import { race, scoped, sleep, until } from "effection";
 import { timeoutFetch as contextualFetchTimeout } from "./config.js";
 import { Files } from "./files.js";
 import { Service } from "./service.js";
+/**
+ * The headers of one response, detached from it.
+ *
+ * Taken while the live response is still in scope, so what a caller reads
+ * afterwards cannot depend on a response that has been disposed, and mutating
+ * the host's own `Headers` cannot change what was read. `get()` keeps the
+ * case-insensitive lookup callers already have, and joins repeated names in
+ * report order — the platform combines them before this sees them, so on the
+ * default adapter there is one entry per name to begin with.
+ */
+function headerPair([name, value]) {
+    return [name, value];
+}
+function detachHeaders(headers) {
+    const entries = [];
+    for (const entry of headers) {
+        entries.push(headerPair(entry));
+    }
+    return {
+        get(key) {
+            const wanted = key.toLowerCase();
+            const found = entries.filter(([name]) => name.toLowerCase() === wanted);
+            return found.length === 0 ? null : found.map(([, value]) => value).join(", ");
+        },
+        entries: () => entries.map(headerPair),
+    };
+}
 /**
  * The `errno` string a failed filesystem call carries, when it carries one.
  *
@@ -311,6 +338,23 @@ export const API = {
                 throw err;
             }
         },
+        *lstat(path) {
+            try {
+                const s = yield* fsLstat(path);
+                return {
+                    exists: true,
+                    isFile: s.isFile(),
+                    isDirectory: s.isDirectory(),
+                    isSymbolicLink: s.isSymbolicLink(),
+                };
+            }
+            catch (err) {
+                if (errorCode(err) === "ENOENT") {
+                    return { exists: false, isFile: false, isDirectory: false, isSymbolicLink: false };
+                }
+                throw err;
+            }
+        },
         *glob(options) {
             const { patterns, root, exclude = [] } = options;
             const matched = [];
@@ -356,18 +400,29 @@ export const API = {
     Fetch: createApi("runtime.fetch", {
         *fetch(input, init) {
             const timeout = init?.timeout ?? (yield* contextualFetchTimeout);
-            const response = yield* withTimeout(`fetch(${input})`, timeout, effectionFetch(input, {
+            const request = effectionFetch(input, {
                 method: init?.method,
                 headers: init?.headers,
                 body: init?.body,
-            }));
-            return {
+            });
+            const response = yield* withTimeout(`fetch(${input})`, timeout, init?.expect === true ? request.expect() : request);
+            // Read here, while the live response is still this scope's: a caller that
+            // keeps the value reads a snapshot rather than a handle on a response
+            // that has since been disposed. Collected through `forEach` rather than
+            // by iterating: the host `Headers` this reads is typed as iterable under
+            // some of the libs this package is built against and not others, and an
+            // array is iterable under all of them.
+            const entries = [];
+            response.headers.forEach((value, name) => entries.push([name, value]));
+            const headers = detachHeaders(entries);
+            const settled = {
                 status: response.status,
-                headers: response.headers,
+                headers,
                 *text() {
                     return yield* withTimeout(`fetch(${input}).text()`, timeout, response.text());
                 },
             };
+            return settled;
         },
     }),
     /**
@@ -421,13 +476,31 @@ export function exec(options) {
 }
 export const readTextFile = API.Fs.operations.readTextFile;
 export const stat = API.Fs.operations.stat;
+export const lstat = API.Fs.operations.lstat;
 export const glob = API.Fs.operations.glob;
 export const writeTextFile = API.Fs.operations.writeTextFile;
 export const ensureDir = API.Fs.operations.ensureDir;
 export const rename = API.Fs.operations.rename;
 export const remove = API.Fs.operations.remove;
 export const realpath = API.Fs.operations.realpath;
-export const fetch = API.Fetch.operations.fetch;
+function chain(input, init) {
+    const settled = () => API.Fetch.operations.fetch(input, init);
+    return {
+        [Symbol.iterator]: () => settled()[Symbol.iterator](),
+        *text() {
+            return yield* (yield* settled()).text();
+        },
+        *json() {
+            return JSON.parse(yield* (yield* settled()).text());
+        },
+        // Recorded on the request rather than checked on the answer, so the whole
+        // middleware chain sees what the caller asked for.
+        expect: () => chain(input, { ...init, expect: true }),
+    };
+}
+export function fetch(input, init) {
+    return chain(input, init);
+}
 export const env = API.Env.operations.env;
 export const cwd = API.Env.operations.cwd;
 export const platform = API.Env.operations.platform;

package/esm/deno-agent-session-coordinator.js

@@ -0,0 +1,228 @@
+/**
+ * The Deno implementation of session ownership.
+ *
+ * Constructed at a runtime-named boundary and handed to a provider by the host
+ * that built it. Shared modules never reach for it, and never ask what runtime
+ * they are on.
+ *
+ * Exclusivity is the kernel's, and durability is the filesystem's, because the
+ * two questions are different. The advisory lock answers "is another live
+ * process in this session right now", which a crash correctly ends. The
+ * ownership record answers "did the last owner prove it stopped", which a crash
+ * must *not* end — so the record is written active before any provider work and
+ * replaced with idle only after the body acknowledges quiescence. A process
+ * that dies in between releases the lock and leaves the active record, and the
+ * next owner refuses rather than inferring safety from a pid, an elapsed time,
+ * an empty transcript, or the lock being free.
+ *
+ * A process-local occupancy table sits in front of both. Advisory locks are
+ * per-process on some hosts, so two provider scopes in one process could
+ * otherwise both believe they hold the same session.
+ */
+import * as dntShim from "./_dnt.shims.js";
+import { ensure, Err, Ok, scoped, until } from "effection";
+import { join } from "node:path";
+import { AgentSessionBusy, agentSessionKeyDigest, AgentSessionRecoveryRequired, parseAgentSessionOwnership, serializeAgentSessionOwnership, } from "./agent-session-coordinator.js";
+/** One of the host's methods, bound to it, or nothing when it has none. */
+function callable(host, name) {
+    const member = Reflect.get(host, name);
+    if (typeof member !== "function") {
+        return undefined;
+    }
+    return (...args) => Reflect.apply(member, host, args);
+}
+function hostFile(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const tryLock = callable(value, "tryLock");
+    const unlock = callable(value, "unlock");
+    const sync = callable(value, "sync");
+    const close = callable(value, "close");
+    if (!tryLock || !unlock || !sync || !close) {
+        return undefined;
+    }
+    return {
+        tryLock: (exclusive) => Promise.resolve(tryLock(exclusive)),
+        unlock: () => Promise.resolve(unlock()),
+        sync: () => Promise.resolve(sync()),
+        close: () => {
+            close();
+        },
+    };
+}
+function coordinatorHost() {
+    if (!Reflect.has(dntShim.dntGlobalThis, "Deno")) {
+        return undefined;
+    }
+    const host = Reflect.get(dntShim.dntGlobalThis, "Deno");
+    if (typeof host !== "object" || host === null) {
+        return undefined;
+    }
+    const names = ["mkdir", "open", "readTextFile", "writeTextFile", "rename", "remove"];
+    const calls = {};
+    for (const name of names) {
+        const call = callable(host, name);
+        if (!call) {
+            return undefined;
+        }
+        calls[name] = call;
+    }
+    return {
+        mkdir: (path, options) => Promise.resolve(calls.mkdir(path, options)),
+        open: (path, options) => Promise.resolve(calls.open(path, options)),
+        readTextFile: (path) => Promise.resolve(calls.readTextFile(path)).then((value) => String(value)),
+        writeTextFile: (path, data, options) => Promise.resolve(calls.writeTextFile(path, data, options)),
+        rename: (from, to) => Promise.resolve(calls.rename(from, to)),
+        remove: (path) => Promise.resolve(calls.remove(path)),
+    };
+}
+/** Whether this host can coordinate agent sessions at all. */
+export function hasDenoAgentSessionCoordinator() {
+    return coordinatorHost() !== undefined;
+}
+function isMissing(cause) {
+    return ((typeof cause === "object" && cause !== null && Reflect.get(cause, "code") === "ENOENT") ||
+        (cause instanceof Error && cause.name === "NotFound"));
+}
+/**
+ * Build the coordinator rooted at `root`.
+ *
+ * Returns nothing on a host with no such filesystem: a host that cannot answer
+ * the ownership question installs no coordinator, and every advertised
+ * provider-returned operation refuses.
+ */
+export function createDenoAgentSessionCoordinator(root) {
+    const found = coordinatorHost();
+    if (!found) {
+        return undefined;
+    }
+    const host = found;
+    // Sibling provider scopes in one process contend here before they contend in
+    // the kernel, because an advisory lock does not always separate them.
+    const occupied = new Set();
+    function* readOwnership(path) {
+        const text = yield* until(host.readTextFile(path).catch((cause) => {
+            if (isMissing(cause)) {
+                return undefined;
+            }
+            throw cause;
+        }));
+        if (text === undefined) {
+            return undefined;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch {
+            throw new AgentSessionRecoveryRequired("the retained agent session ownership record is not readable");
+        }
+        const record = parseAgentSessionOwnership(parsed);
+        if (!record) {
+            throw new AgentSessionRecoveryRequired("the retained agent session ownership record is not valid");
+        }
+        return record;
+    }
+    /**
+     * Replace the ownership record durably.
+     *
+     * Written whole, flushed, renamed over the destination, and the directory
+     * flushed behind it — so a reader sees the old record or the new one, and a
+     * crash cannot leave a half-written state that parses as something weaker.
+     */
+    function* publish(directory, destination, record) {
+        const staging = `${destination}.${record.operationId}.staging`;
+        yield* until(host.writeTextFile(staging, serializeAgentSessionOwnership(record), { mode: 0o600 }));
+        const staged = hostFile(yield* until(host.open(staging, { read: true })));
+        if (staged) {
+            yield* until(staged.sync());
+            staged.close();
+        }
+        yield* until(host.rename(staging, destination));
+        const opened = hostFile(yield* until(host.open(directory, { read: true })));
+        if (opened) {
+            yield* until(opened.sync());
+            opened.close();
+        }
+    }
+    return {
+        coordinate(key, owner, body) {
+            // Scoped, not a resource: ownership has to end when the body ends. A
+            // resource acquired in the caller's scope would hold the lock and the
+            // active record until *that* scope closed, which is a different — and
+            // much longer — lifetime than the work it protects.
+            return scoped(function* () {
+                const digest = agentSessionKeyDigest(key);
+                const leases = join(root, "leases");
+                const ownership = join(root, "ownership");
+                yield* until(host.mkdir(leases, { recursive: true, mode: 0o700 }));
+                yield* until(host.mkdir(ownership, { recursive: true, mode: 0o700 }));
+                const record = join(ownership, `${digest}.json`);
+                if (occupied.has(digest)) {
+                    return Err(busy(key));
+                }
+                occupied.add(digest);
+                yield* ensure(() => {
+                    occupied.delete(digest);
+                });
+                // Opened for the ownership scope and never unlinked: deleting it would
+                // let a second process create a fresh file and lock that instead.
+                const opened = hostFile(yield* until(host.open(join(leases, `${digest}.lease`), {
+                    read: true,
+                    write: true,
+                    create: true,
+                    mode: 0o600,
+                })));
+                if (!opened) {
+                    throw new Error("this host opened a file with no advisory-lock operations");
+                }
+                let locked = false;
+                yield* ensure(function* () {
+                    if (locked) {
+                        yield* until(opened.unlock());
+                    }
+                    opened.close();
+                });
+                locked = (yield* until(opened.tryLock(true))) === true;
+                if (!locked) {
+                    return Err(busy(key));
+                }
+                const retained = yield* readOwnership(record);
+                if (retained?.state === "active") {
+                    // The lock is free and the record is not. Whoever held it last never
+                    // said it had stopped, and nothing here can say it for them.
+                    return Err(new AgentSessionRecoveryRequired(`session "${key.sessionKey}" was left owned by an XMD process that did not ` +
+                        `finish. Nothing here can prove that owner stopped, so it stays owned until ` +
+                        `it is recovered deliberately.`));
+                }
+                const active = {
+                    schema: "agent-session-ownership.v1",
+                    keyDigest: digest,
+                    state: "active",
+                    ownerKind: owner.kind,
+                    operationId: owner.operationId,
+                };
+                yield* publish(ownership, record, active);
+                let quiesced = false;
+                // Registered before the body runs, so an idle record is published on
+                // every ordinary exit — and on none of the others.
+                yield* ensure(function* () {
+                    if (!quiesced) {
+                        return;
+                    }
+                    yield* publish(ownership, record, { ...active, state: "idle" });
+                });
+                return Ok(yield* body({
+                    quiesced() {
+                        quiesced = true;
+                    },
+                }));
+            });
+        },
+    };
+}
+function busy(key) {
+    return new AgentSessionBusy(`another XMD owner is using session "${key.sessionKey}" — a native UI or a turn in ` +
+        `another process holds it. Run this again once that owner exits.`);
+}

package/esm/deno-executable-observer.js

@@ -0,0 +1,159 @@
+/**
+ * The Deno implementation of executable observation.
+ *
+ * Constructed at a runtime-named boundary and handed to a provider by the host
+ * that built it, exactly as the session coordinator is. Shared modules never
+ * reach for it and never ask what runtime they are on.
+ *
+ * Resolution reads the real process environment rather than a contextual one.
+ * That is the whole point of building this here: PATH decides which file is
+ * observed, and a PATH document middleware could move is a PATH that can point
+ * the observation at one binary while the run spawns another. A controlled test
+ * substitutes the entire observer through the same constructor seam the host
+ * uses, so nothing needs a replaceable resolver to be testable.
+ */
+import * as dntShim from "./_dnt.shims.js";
+import { until } from "effection";
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join, resolve } from "node:path";
+import { ExecutableObservationError } from "./executable-observer.js";
+/** One of the host's methods, bound to it, or nothing when it has none. */
+function callable(host, name) {
+    const member = Reflect.get(host, name);
+    if (typeof member !== "function") {
+        return undefined;
+    }
+    return (...args) => Reflect.apply(member, host, args);
+}
+function observerHost() {
+    const found = Reflect.get(dntShim.dntGlobalThis, "Deno");
+    if (typeof found !== "object" || found === null) {
+        return undefined;
+    }
+    const env = Reflect.get(found, "env");
+    const cwd = callable(found, "cwd");
+    const commandCtor = Reflect.get(found, "Command");
+    if (typeof commandCtor !== "function" || !cwd || typeof env !== "object" || env === null) {
+        return undefined;
+    }
+    const toObject = callable(env, "toObject");
+    if (!toObject) {
+        return undefined;
+    }
+    return {
+        command: (path, options) => Reflect.construct(commandCtor, [
+            path,
+            options,
+        ]),
+        env: { toObject: () => toObject() },
+        cwd: () => cwd(),
+    };
+}
+/** Whether this host can observe an executable at all. */
+export function hasDenoExecutableObserver() {
+    return observerHost() !== undefined;
+}
+/** What the version invocation produced, decoded. */
+function decode(value) {
+    if (typeof value !== "object" || value === null) {
+        return { code: -1, text: "" };
+    }
+    const code = Reflect.get(value, "code");
+    const stdout = Reflect.get(value, "stdout");
+    const decoder = new TextDecoder();
+    return {
+        code: typeof code === "number" ? code : -1,
+        text: stdout instanceof Uint8Array ? decoder.decode(stdout) : "",
+    };
+}
+/**
+ * Build an observer rooted in this process's real environment.
+ *
+ * `overrides` exist for the focused proof only: a test that wants to watch
+ * PATH search happen supplies its own search path and working directory rather
+ * than moving the ones every other thing in the process is using.
+ */
+export function createDenoExecutableObserver(overrides) {
+    const found = observerHost();
+    if (!found) {
+        return undefined;
+    }
+    const host = found;
+    function* resolveCommand(command) {
+        if (command.length === 0) {
+            throw new ExecutableObservationError("no executable was named", { refusal: "not-found" });
+        }
+        const base = overrides?.cwd ?? host.cwd();
+        if (command.includes("/") || command.includes("\\") || isAbsolute(command)) {
+            return resolve(base, command);
+        }
+        const search = overrides?.path ?? host.env.toObject().PATH ?? "";
+        for (const entry of search.split(delimiter)) {
+            if (entry.length === 0) {
+                continue;
+            }
+            const candidate = join(entry, command);
+            const found = yield* until(stat(candidate).then(() => true, () => false));
+            if (found) {
+                return candidate;
+            }
+        }
+        throw new ExecutableObservationError(`no executable named ${command} was found on the search path`, { refusal: "not-found" });
+    }
+    return {
+        *observe(command, options) {
+            const resolved = yield* resolveCommand(command);
+            // Canonicalized before stat, hash and version: a symlinked launcher shim
+            // and the build it points at are one file, so the same build reached two
+            // ways produces one digest — and the version comes from that same file
+            // rather than from whatever the shim would have re-resolved.
+            const path = yield* until(realpath(resolved).catch(() => resolved));
+            const info = yield* until(stat(path).catch((cause) => {
+                throw new ExecutableObservationError(`${command} could not be inspected`, {
+                    refusal: "not-found",
+                    cause,
+                });
+            }));
+            if (!info.isFile()) {
+                throw new ExecutableObservationError(`${command} does not name a regular file`, {
+                    refusal: "not-a-file",
+                });
+            }
+            // Any execute bit is enough: which one applies depends on who is asking,
+            // and a file with none of them is not a program under any of them.
+            if ((info.mode & 0o111) === 0) {
+                throw new ExecutableObservationError(`${command} is not executable`, {
+                    refusal: "not-executable",
+                });
+            }
+            const bytes = yield* until(readFile(path).catch((cause) => {
+                throw new ExecutableObservationError(`${command} could not be read`, {
+                    refusal: "unreadable",
+                    cause,
+                });
+            }));
+            const versionArgs = options?.versionArgs ?? ["--version"];
+            const produced = yield* until(host
+                .command(path, { args: [...versionArgs], stdout: "piped", stderr: "null" })
+                .output()
+                .catch((cause) => {
+                throw new ExecutableObservationError(`${command} could not be asked its version`, {
+                    refusal: "version-unavailable",
+                    cause,
+                });
+            }));
+            const version = decode(produced);
+            if (version.code !== 0) {
+                throw new ExecutableObservationError(`${command} refused to report a version`, {
+                    refusal: "version-unavailable",
+                });
+            }
+            return {
+                path,
+                digest: { algorithm: "sha256", value: createHash("sha256").update(bytes).digest("hex") },
+                versionOutput: version.text,
+            };
+        },
+    };
+}