cloving 1.4.0 → 1.5.0

package/dist/src/daemon/daemon.js

@@ -13,8 +13,13 @@ import { worldDirectory } from "./host-environment.js";
 import { pinnedWorkflowHandler } from "./workflow-replay.js";
 import { scheduledDeclarations } from "./workflow-schedules.js";
 import { scheduleConnection } from "./schedule-control.js";
+import { queueConnection } from "./queue-control.js";
 import { daemonLoops } from "./daemon-loops.js";
-import { ticketRegistrations, ticketRegistrationTable, } from "./ticket-registration.js";
+import { authorityRuns, recordRetention } from "./record-sweep.js";
+import { turnDetailsPlace } from "./turn-details.js";
+import { defaultRetention } from "../record-retention.js";
+import { clovingVersion } from "../cli/toolchain.js";
+import { daemonRegistrations, queueWorkflowId, workflowReload, } from "./workflow-reload.js";
 export const turnLeaseMilliseconds = 4 * 3_600_000;
 export const loopMilliseconds = 250;
 export const bridgeTiming = {
@@ -66,45 +71,6 @@ async function hosted(settings, hosting) {
         },
     };
 }
-async function daemonRegistrations(settings) {
-    const conflict = settings.workflowRefusals?.find((refusal) => refusal.codes.includes("queue-workflow-conflict"));
-    if (conflict !== undefined)
-        return {
-            table: [],
-            admitted: {
-                kind: "rejected",
-                detail: `queue-workflow-conflict: ${conflict.scope} ${conflict.label}`,
-            },
-        };
-    const table = ticketRegistrationTable({
-        repository: settings.repository,
-        command: settings.ticketCommand,
-        nextCommand: settings.nextCommand,
-        githubCommand: settings.githubCommand,
-    }, settings.declarations);
-    const admitted = await ticketRegistrations(settings.manifests, {
-        table,
-        commands: settings.commands ?? {},
-        ...(settings.bundleDigest === undefined
-            ? {}
-            : { bundleDigest: settings.bundleDigest }),
-    });
-    return {
-        table,
-        admitted: admitted.kind === "rejected"
-            ? admitted
-            : {
-                ...admitted,
-                registrations: admitted.registrations.map((registration) => ({
-                    ...registration,
-                    ...(settings.queueMilliseconds !== undefined &&
-                        registration.workflowId === queueWorkflowId(settings)
-                        ? { admission: settings.queueLanes ?? 1, queue: true }
-                        : {}),
-                })),
-            },
-    };
-}
 export async function startDaemon(givenSettings) {
     const repository = await realpath(givenSettings.repository);
     const scheduled = scheduledDeclarations(givenSettings, {
@@ -119,16 +85,56 @@ export async function startDaemon(givenSettings) {
         repository,
     });
 }
+function controlConnections() {
+    return { schedules: scheduleConnection(), queues: queueConnection() };
+}
+function retentionReads(settings, ports) {
+    return turnDetailsPlace({
+        directory: settings.directory,
+        retention: settings.retention ?? defaultRetention,
+        runs: async (runIds) => authorityRuns(await ports)(runIds),
+        now: settings.retentionClock ?? Date.now,
+    });
+}
+function rejectedOpening(detail) {
+    return {
+        kind: "refused",
+        reason: detail.startsWith("queue-workflow-conflict")
+            ? "queue-workflow-conflict"
+            : "workflow-rejected",
+        detail,
+    };
+}
+function workflowOptions(settings, parts) {
+    const { reloadCommand, loadBundle } = settings;
+    const { generations, turnSettings } = parts;
+    return {
+        workflowBundles: {
+            directory: join(settings.directory, "workflow-bundles"),
+            repository: settings.repository,
+        },
+        workflowRefusals: settings.workflowRefusals ?? [],
+        retainedWorkflow: generations.available,
+        ...(settings.bundleDigest === undefined
+            ? {}
+            : { bundleDigest: settings.bundleDigest }),
+        ...(reloadCommand === undefined || loadBundle === undefined
+            ? {}
+            : {
+                reload: workflowReload({
+                    ...settings,
+                    reloadCommand,
+                    loadBundle,
+                    generations,
+                    turnSettings,
+                }),
+            }),
+    };
+}
 async function openDaemon(settings) {
     const { table, admitted } = await daemonRegistrations(settings);
     if (admitted.kind === "rejected")
-        return {
-            kind: "refused",
-            reason: admitted.detail.startsWith("queue-workflow-conflict")
-                ? "queue-workflow-conflict"
-                : "workflow-rejected",
-            detail: admitted.detail,
-        };
+        return rejectedOpening(admitted.detail);
     const given = Promise.withResolvers();
     const generations = workflowGenerations({
         ...settings,
@@ -139,23 +145,21 @@ async function openDaemon(settings) {
     const { worker, github, runs, handoff, commands } = resources;
     await mkdir(join(settings.directory, "state"), { recursive: true });
     await mkdir(settings.runtimeDirectory, { recursive: true, mode: 0o700 });
-    const schedules = scheduleConnection();
+    const controls = controlConnections();
     const opening = await startService({
-        schedule: schedules.request,
+        version: clovingVersion,
+        schedule: controls.schedules.request,
+        queue: controls.queues.port,
         ...(settings.queueDailySpendLimitUsd === undefined
             ? {}
             : { queueDailySpendLimitUsd: settings.queueDailySpendLimitUsd }),
         workerHarness: worker.harness,
+        turnDetails: retentionReads(settings, given.promise),
         commandEffects: commandEffects(join(settings.directory, "commands")),
         stateDirectory: join(settings.directory, "state"),
         runtimeDirectory: settings.runtimeDirectory,
-        workflowBundles: {
-            directory: join(settings.directory, "workflow-bundles"),
-            repository: settings.repository,
-        },
-        workflowRefusals: settings.workflowRefusals ?? [],
+        ...workflowOptions(settings, { ...resources, generations }),
         workflows: admitted.registrations,
-        retainedWorkflow: generations.available,
         delivery: deliveryRouter({
             runs,
             effects: { claude: worker, github, handoff, command: commands },
@@ -170,11 +174,11 @@ async function openDaemon(settings) {
         await closeWorkers(resources);
         return opening;
     }
-    const running = { ...resources, service: opening.service, schedules };
+    const running = { ...resources, ...controls, service: opening.service };
     await recoverWorkers(running, given.promise);
     return {
         kind: "started",
-        daemon: await runningDaemon(settings, running),
+        daemon: await runningDaemon(settings, { ...running, ports: given.promise }),
     };
 }
 async function recoverWorkers(resources, ports) {
@@ -200,13 +204,22 @@ async function closeWorkers(resources) {
 }
 async function runningDaemon(settings, resources) {
     const { service, github } = resources;
+    const retention = await recordRetention({
+        directory: settings.directory,
+        retention: settings.retention ?? defaultRetention,
+        runs: authorityRuns(await resources.ports),
+        now: settings.retentionClock ?? Date.now,
+        log: (line) => process.stderr.write(line),
+    });
     await github.scan();
     const loops = await daemonLoops({
         ...settings,
         scheduleConnection: resources.schedules,
+        queueConnection: resources.queues,
         submit: service.worker.submit,
         queueWorkflowId: queueWorkflowId(settings),
     }).catch(async (error) => {
+        await retention.stop();
         await closeWorkers(resources);
         await service.close();
         throw error;
@@ -214,12 +227,10 @@ async function runningDaemon(settings, resources) {
     return {
         socket: service.socket,
         close: async () => {
+            await retention.stop();
             await loops.stop();
             await closeWorkers(resources);
             await service.close();
         },
     };
 }
-function queueWorkflowId(settings) {
-    return settings.declarations?.find((declaration) => declaration.queue === true)?.workflowId;
-}

package/dist/src/daemon/github-attach.js

@@ -1,4 +1,4 @@
-import { rm } from "node:fs/promises";
+import { rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { copiedAttachment, openedAttachment } from "./attachment-file.js";
 import { attachmentFolder } from "./attachments.js";
@@ -6,6 +6,7 @@ import { repositoryName } from "./github-issue-methods.js";
 import { issuePrivacy, operatorPrivateTexts } from "./github-issue-privacy.js";
 import { field, repositoryPath, text, } from "./github-operation.js";
 import { githubRead } from "./github-retry.js";
+import { inTurn } from "./merge-turns.js";
 function isList(value) {
     return Array.isArray(value);
 }
@@ -15,6 +16,12 @@ function validName(name) {
 function validRelease(release) {
     return /^[a-z][a-z0-9-]{0,63}$/.test(release) && !/^v\d/.test(release);
 }
+function placeOf(operation) {
+    const place = operation.payload["place"] ?? "comment";
+    if (place !== "comment" && place !== "description")
+        throw new Error("invalid-payload");
+    return place;
+}
 function attachmentOf(operation) {
     const number = operation.payload["number"];
     const name = text(operation, "name");
@@ -24,7 +31,7 @@ function attachmentOf(operation) {
         throw new Error("invalid-payload");
     if (!validName(name) || !validRelease(release) || comment.length > 4000)
         throw new Error("invalid-payload");
-    return { number, name, release, comment };
+    return { number, name, release, comment, place: placeOf(operation) };
 }
 function attachedFile(operation, name) {
     return openedAttachment({
@@ -129,6 +136,73 @@ async function commented(operation, attachment) {
         `body=${body}`,
     ]);
 }
+function withSection(body, marks) {
+    const from = body.indexOf(marks.start);
+    const to = from < 0 ? -1 : body.indexOf(marks.end, from);
+    if (to >= 0)
+        return (body.slice(0, from) + marks.section + body.slice(to + marks.end.length));
+    const kept = body.trimEnd();
+    return kept === "" ? marks.section : `${kept}\n\n${marks.section}`;
+}
+async function pullBody(operation, number) {
+    const pull = JSON.parse(await githubRead(operation, [
+        "api",
+        `${repositoryPath}/pulls/${String(number)}`,
+    ]));
+    const body = field(pull, "body");
+    return typeof body === "string" ? body : "";
+}
+function attachedUrl(body, marks) {
+    const from = body.indexOf(marks.start);
+    const to = from < 0 ? -1 : body.indexOf(marks.end, from);
+    const url = to < 0 ? "" : (body.slice(from, to).trimEnd().split("\n").at(-1) ?? "");
+    if (!/^https:\/\/github\.com\/user-attachments\/assets\/[\w-]+$/.test(url))
+        throw new Error("github-call-failed");
+    return url;
+}
+async function described(operation, attachment) {
+    const { number, name } = attachment;
+    const start = `<!-- cloving-attachment:${String(number)}:${name} -->`;
+    const end = `<!-- /cloving-attachment:${String(number)}:${name} -->`;
+    const section = `${start}\n${attachment.comment}\n\n![${name}](./${name})\n${end}`;
+    const copy = join(operation.folder, name);
+    const text = join(operation.folder, "body.md");
+    const turn = {
+        key: `${operation.settings.repository}#pull-${String(number)}`,
+        signal: operation.signal,
+    };
+    try {
+        await copiedAttachment(attachment.file, copy);
+        await inTurn(turn, async () => {
+            const current = await pullBody(operation, number);
+            await writeFile(text, withSection(current, { start, end, section }), "utf8");
+            await operation.calls.gh([
+                "pr",
+                "edit",
+                String(number),
+                "--body-file",
+                text,
+                "--attach",
+                copy,
+            ]);
+        });
+    }
+    finally {
+        await rm(copy, { force: true });
+        await rm(text, { force: true });
+    }
+    return attachedUrl(await pullBody(operation, number), {
+        start,
+        end,
+    });
+}
+async function delivered(operation, attachment) {
+    if (attachment.place === "description")
+        return await described(operation, attachment);
+    const url = await uploaded(operation, attachment);
+    await commented(operation, { ...attachment, url });
+    return url;
+}
 export async function attachAsset(operation) {
     const attachment = attachmentOf(operation);
     operatorPrivateTexts(operation.settings);
@@ -139,8 +213,7 @@ export async function attachAsset(operation) {
     });
     const file = await attachedFile(operation, attachment.name);
     try {
-        const url = await uploaded(operation, { ...attachment, file });
-        await commented(operation, { ...attachment, url });
+        const url = await delivered(operation, { ...attachment, file });
         return { number: attachment.number, url };
     }
     finally {

package/dist/src/daemon/github-calls.js

@@ -24,7 +24,7 @@ function failureDetail(error, place) {
     const text = typeof stderr === "string" ? stderr : "";
     return {
         detail: githubText(text, place).slice(-2_000),
-        status: Number(/\(HTTP (\d{3})\)/.exec(text)?.[1]),
+        status: Number(/\bHTTP (\d{3})\b/.exec(text)?.[1]),
     };
 }
 export function githubText(text, settings) {

package/dist/src/daemon/github-methods.js

@@ -5,6 +5,7 @@ import { findingsOf, scoreOf, } from "./github-calls.js";
 import { attachAsset } from "./github-attach.js";
 import { closeIssue, partialIssue } from "./github-ticket-status.js";
 import { merge } from "./github-merge.js";
+import { inMergeTurn } from "./merge-turns.js";
 import { captureDraft, createIssue, discard, repositoryName, } from "./github-issue-methods.js";
 import { existingTree, defaultBranch, changeChecked, field, githubTiming, repositoryPath, text, } from "./github-operation.js";
 import { workTree } from "./work-tree.js";
@@ -277,10 +278,13 @@ export const methods = new Map([
     ["wait-review", waitReview],
     [
         "merge",
-        (operation) => merge(operation, {
+        (operation) => inMergeTurn({
+            repository: operation.settings.repository,
+            signal: operation.signal,
+        }, () => merge(operation, {
             number: integer(operation, "number"),
             commit: text(operation, "commit"),
             check: mergeCheck(operation),
-        }),
+        })),
     ],
 ]);

package/dist/src/daemon/issue-queue.d.ts

@@ -1,3 +1,4 @@
+import { type QueuePort } from "../queue-state.ts";
 interface QueueSettings {
     readonly directory: string;
     readonly runtimeDirectory: string;
@@ -8,5 +9,7 @@ interface QueueSettings {
 }
 export declare function issueQueue(settings: QueueSettings): {
     readonly stop: () => Promise<void>;
+    readonly port: QueuePort;
+    readonly ready: Promise<void>;
 };
 export {};

package/dist/src/daemon/issue-queue.js

@@ -1,57 +1,14 @@
 import { queueStatus, spendNotice } from "./queue-status.js";
 import { randomUUID } from "node:crypto";
-import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { send } from "../cli/client.js";
 import { record } from "../protocol.js";
 import { runIdentity } from "../service/submission-handler.js";
-function savedHold(value) {
-    if (value === undefined)
-        return undefined;
-    const held = record(value);
-    if (typeof held?.["mark"] !== "string" ||
-        typeof held["startedAt"] !== "number" ||
-        !Number.isFinite(held["startedAt"]) ||
-        held["startedAt"] <= 0)
-        throw new Error("invalid-queue-commands");
-    return { mark: held["mark"], startedAt: held["startedAt"] };
-}
-function identifiers(value) {
-    if (!Array.isArray(value) ||
-        !value.every((id) => typeof id === "string" && id.length > 0))
-        throw new Error("invalid-queue-commands");
-    return value.map(String);
-}
-async function journal(directory) {
-    const file = join(directory, "queue-commands.json");
-    const text = await readFile(file, "utf8").catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return "[]";
-        throw error;
-    });
-    const value = JSON.parse(text);
-    const saved = record(value);
-    const commands = new Set(identifiers(Array.isArray(value) ? value : saved?.["commands"]));
-    const failures = Array.isArray(value) ? [] : identifiers(saved?.["failures"]);
-    if (failures.length > 3)
-        throw new Error("invalid-queue-commands");
-    const pending = {
-        commands,
-        failures,
-        retryCommandId: undefined,
-        selfUpdateHold: savedHold(saved?.["selfUpdateHold"]),
-        save: async () => {
-            await writeFile(`${file}.tmp`, JSON.stringify({
-                commands: [...commands],
-                failures,
-                selfUpdateHold: pending.selfUpdateHold,
-            }) + "\n", { mode: 0o600, flush: true });
-            await rename(`${file}.tmp`, file);
-        },
-    };
-    return pending;
-}
+import { queueFailureLimit } from "../queue-state.js";
+import { queueJournal } from "./queue-journal.js";
+import { queueControlPort, queueStopped, } from "./queue-control.js";
 function terminal(run) {
     return ["completed", "failed", "cancelled"].includes(String(run["state"]));
 }
@@ -111,11 +68,18 @@ function handedOff(run) {
         outcome?.["kind"] === "handoff_requested" &&
         outcome["issueUpdate"] !== "failed");
 }
-class QueueFailureLimit extends Error {
+function limited(pending) {
+    return pending.failures.length >= queueFailureLimit;
 }
-function checkFailureLimit(pending) {
-    if (pending.failures.length >= 3)
-        throw new QueueFailureLimit(`3 runs in a row ended without handoff: ${pending.failures.join(", ")}`);
+function stopNotice() {
+    let noticed = false;
+    return (pending) => {
+        const stopped = limited(pending);
+        if (stopped && !noticed)
+            process.stderr.write(`Queue stopped: 3 runs in a row ended without handoff: ${pending.failures.join(", ")}\n`);
+        noticed = stopped;
+        return stopped;
+    };
 }
 async function retired(pending, ending) {
     const { commandId, run } = ending;
@@ -125,14 +89,12 @@ async function retired(pending, ending) {
     else
         pending.failures.push(runIdentity(commandId));
     await pending.save();
-    checkFailureLimit(pending);
-    if (handedOff(run))
+    if (handedOff(run) || limited(pending))
         return;
     const outcome = record(run["outcome"]);
     process.stderr.write(`Queue run ended ${String(outcome?.["kind"] ?? run["state"])}${outcome?.["issueUpdate"] === "failed" ? "; issueUpdate: failed" : ""}: ${runIdentity(commandId)}; continuing\n`);
 }
 async function completed(settings, pending) {
-    checkFailureLimit(pending);
     let pendingRuns = 0;
     const endings = [];
     const tracked = [...pending.commands].filter((commandId) => commandId !== pending.retryCommandId);
@@ -145,7 +107,8 @@ async function completed(settings, pending) {
     endings.sort((first, second) => Number(first.run["terminalSequence"] ?? first.run["latestSequence"] ?? 0) -
         Number(second.run["terminalSequence"] ?? second.run["latestSequence"] ?? 0));
     for (const ending of endings)
-        await retired(pending, ending);
+        if (!limited(pending))
+            await retired(pending, ending);
     return pendingRuns;
 }
 async function submit(settings, pending) {
@@ -230,21 +193,49 @@ async function admission(settings, attempt) {
     const file = join(settings.directory, "queue-submission");
     await writeFile(file, "", { mode: 0o600 });
     try {
-        if (!(await attempt.holding()) && !attempt.signal.aborted)
+        if (!(await attempt.holding()) &&
+            !attempt.signal.aborted &&
+            attempt.pending.drain === undefined)
             await submit(settings, attempt.pending);
     }
     finally {
         await rm(file, { force: true });
     }
 }
-async function cycle(settings, signal) {
-    const pending = await journal(settings.directory);
+async function drained(pending, busy) {
+    const { drain } = pending;
+    if (drain === undefined || drain.drainedAt !== null || busy > 0)
+        return;
+    pending.drain = { ...drain, drainedAt: Date.now() };
+    await pending.save();
+    process.stderr.write("Queue drained\n");
+}
+async function admissible(settings, checks) {
+    const { pending, stop } = checks;
+    const pendingRuns = stop(pending) ? 0 : await completed(settings, pending);
+    if (stop(pending) && pending.drain === undefined)
+        return false;
+    const status = await queueStatus(settings);
+    await drained(pending, status.busy);
+    if (stop(pending) || pending.drain !== undefined)
+        return false;
+    const spend = checks.notice(status);
+    const updating = await checks.update(status.busy);
+    const lanes = settings.lanes ?? 1;
+    if (Math.max(pendingRuns, status.busy) >= lanes || status.busy < pendingRuns)
+        return false;
+    return !updating && !spend;
+}
+async function cycle(settings, run) {
+    const { signal, pending } = run;
     if (settings.resetQueue === true) {
         pending.failures.length = 0;
+        pending.drain = undefined;
         await pending.save();
     }
     const update = updateHold(settings.directory, pending);
     const notice = spendNotice();
+    const stop = stopNotice();
     const holding = async (activeRuns = 0) => {
         const updating = await update(activeRuns);
         const spend = notice(await queueStatus(settings));
@@ -257,15 +248,7 @@ async function cycle(settings, signal) {
         await delay(settings.intervalMilliseconds, undefined, { signal }).catch(() => undefined);
         if (stopped())
             return;
-        const pendingRuns = await completed(settings, pending);
-        const lanes = settings.lanes ?? 1;
-        const status = await queueStatus(settings);
-        const spend = notice(status);
-        const updating = await update(status.busy);
-        if (Math.max(pendingRuns, status.busy) >= lanes ||
-            status.busy < pendingRuns)
-            continue;
-        if (updating || spend)
+        if (!(await admissible(settings, { pending, stop, notice, update })))
             continue;
         if (stopped())
             return;
@@ -273,16 +256,26 @@ async function cycle(settings, signal) {
     }
 }
 export function issueQueue(settings) {
-    const stopping = new AbortController();
-    const running = cycle(settings, stopping.signal).catch((error) => {
-        const reason = error instanceof Error ? error.message : String(error);
-        const diagnostic = error instanceof QueueFailureLimit ? reason : JSON.stringify(reason);
-        process.stderr.write(`Queue stopped: ${diagnostic}\n`);
+    const runtime = {
+        pending: undefined,
+        error: undefined,
+        stopping: new AbortController(),
+    };
+    const loaded = queueJournal(settings.directory).then((pending) => {
+        runtime.pending = pending;
+        return pending;
+    });
+    const running = loaded
+        .then((pending) => cycle(settings, { signal: runtime.stopping.signal, pending }))
+        .catch((error) => {
+        queueStopped(runtime, error);
     });
     return {
         stop: async () => {
-            stopping.abort();
+            runtime.stopping.abort();
             await running;
         },
+        port: queueControlPort(runtime),
+        ready: loaded.then(() => undefined, () => undefined),
     };
 }

package/dist/src/daemon/merge-turns.d.ts

@@ -0,0 +1,10 @@
+export interface Turn {
+    readonly key: string;
+    readonly signal: AbortSignal;
+}
+export interface MergeTurn {
+    readonly repository: string;
+    readonly signal: AbortSignal;
+}
+export declare function inTurn<Result>(turn: Turn, work: () => Promise<Result>): Promise<Result>;
+export declare function inMergeTurn<Result>(turn: MergeTurn, work: () => Promise<Result>): Promise<Result>;

package/dist/src/daemon/merge-turns.js

@@ -0,0 +1,37 @@
+const turns = new Map();
+function waited(previous, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const aborted = () => {
+            const reason = signal.reason;
+            reject(reason instanceof Error ? reason : new Error("merge-turn-aborted"));
+        };
+        signal.addEventListener("abort", aborted, { once: true });
+        previous.then(() => {
+            signal.removeEventListener("abort", aborted);
+            resolve(undefined);
+        }, reject);
+    });
+}
+export async function inTurn(turn, work) {
+    const previous = turns.get(turn.key) ?? Promise.resolve(undefined);
+    const ended = Promise.withResolvers();
+    const queued = previous
+        .then(() => ended.promise)
+        .then(() => {
+        if (turns.get(turn.key) === queued)
+            turns.delete(turn.key);
+        return undefined;
+    });
+    turns.set(turn.key, queued);
+    try {
+        await waited(previous, turn.signal);
+        return await work();
+    }
+    finally {
+        ended.resolve(undefined);
+    }
+}
+export function inMergeTurn(turn, work) {
+    return inTurn({ key: turn.repository, signal: turn.signal }, work);
+}

package/dist/src/daemon/queue-control.d.ts

@@ -0,0 +1,13 @@
+import type { QueuePort } from "../queue-state.ts";
+import { type QueueJournal } from "./queue-journal.ts";
+export interface QueueRuntime {
+    pending: QueueJournal | undefined;
+    error: string | undefined;
+    readonly stopping: AbortController;
+}
+export declare function queueConnection(): {
+    readonly port: QueuePort;
+    readonly connect: (port: QueuePort) => void;
+};
+export declare function queueStopped(runtime: QueueRuntime, error: unknown): string;
+export declare function queueControlPort(runtime: QueueRuntime): QueuePort;