voratiq 0.1.0-beta.2 → 0.1.0-beta.21

package/dist/persistence/session-store.js

@@ -0,0 +1,412 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { isFileSystemError, pathExists } from "../utils/fs.js";
+import { relativeToRoot } from "../utils/path.js";
+import { SessionOptionValidationError, SessionRecordMutationError, SessionRecordNotFoundError, SessionRecordParseError, } from "./errors.js";
+const BUFFER_FLUSH_DELAY_MS = 250;
+export function createSessionStore(config) {
+    const buffer = new Map();
+    let readRecordsImpl = readRecordsInternal;
+    function setReadRecordsImplementation(implementation) {
+        readRecordsImpl = implementation;
+    }
+    function resetReadRecordsImplementation() {
+        readRecordsImpl = readRecordsInternal;
+    }
+    async function readRecordsInternal(options) {
+        const { paths, limit, predicate, onWarning } = options;
+        if (limit !== undefined && (!Number.isInteger(limit) || limit <= 0)) {
+            throw new SessionOptionValidationError("limit", "must be a positive integer");
+        }
+        let index;
+        try {
+            index = await readIndex(paths.indexPath);
+        }
+        catch (error) {
+            if (error instanceof SessionRecordParseError) {
+                const displayPath = relativeToRoot(paths.root, paths.indexPath);
+                throw new SessionRecordParseError(displayPath, error.details);
+            }
+            throw error;
+        }
+        const matches = [];
+        for (let i = index.sessions.length - 1; i >= 0; i -= 1) {
+            const entry = index.sessions[i];
+            if (!entry) {
+                continue;
+            }
+            const sessionId = config.getIndexEntryId(entry);
+            const recordPath = join(paths.sessionsDir, sessionId, config.recordFilename);
+            try {
+                const record = await readRecordFromDisk(recordPath);
+                if (predicate && !predicate(record)) {
+                    continue;
+                }
+                matches.push(record);
+                if (limit !== undefined && matches.length >= limit) {
+                    break;
+                }
+            }
+            catch (error) {
+                if (error instanceof SessionRecordParseError) {
+                    const warning = {
+                        kind: "parse-error",
+                        sessionId,
+                        recordPath,
+                        displayPath: relativeToRoot(paths.root, recordPath),
+                        details: error.details,
+                    };
+                    onWarning?.(warning);
+                    continue;
+                }
+                if (error instanceof SessionRecordNotFoundError) {
+                    const warning = {
+                        kind: "missing-record",
+                        sessionId,
+                        recordPath,
+                        displayPath: relativeToRoot(paths.root, recordPath),
+                    };
+                    onWarning?.(warning);
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return matches;
+    }
+    async function readRecords(options) {
+        return readRecordsImpl(options);
+    }
+    async function appendRecord(options) {
+        const { paths, record } = options;
+        const sessionId = config.getRecordId(record);
+        const recordDir = join(paths.sessionsDir, sessionId);
+        const recordPath = join(recordDir, config.recordFilename);
+        const displayPath = relativeToRoot(paths.root, recordPath);
+        await mkdir(recordDir, { recursive: true });
+        const releaseLock = await config.acquireLock(paths.lockPath);
+        try {
+            if (await pathExists(recordPath)) {
+                throw new SessionRecordMutationError(`Session ${sessionId} already exists at ${displayPath}.`);
+            }
+            await atomicWriteRecord(recordPath, record);
+            await upsertIndexEntry(paths.indexPath, config.buildIndexEntry(record));
+            registerBufferEntry({
+                key: recordPath,
+                sessionId,
+                recordPath,
+                lockPath: paths.lockPath,
+                sessionsDir: paths.sessionsDir,
+                indexPath: paths.indexPath,
+                root: paths.root,
+                record,
+                lastPersistedStatus: config.getRecordStatus(record),
+                dirty: false,
+            });
+        }
+        catch (error) {
+            if (error instanceof SessionRecordMutationError) {
+                throw error;
+            }
+            if (isFileSystemError(error)) {
+                throw new SessionRecordMutationError(`Failed to initialize session history at ${displayPath}: ${error.message}`);
+            }
+            throw error;
+        }
+        finally {
+            await releaseLock();
+        }
+    }
+    async function rewriteRecord(options) {
+        const { paths, sessionId, mutate, forceFlush = false } = options;
+        const recordPath = join(paths.sessionsDir, sessionId, config.recordFilename);
+        const entry = await getOrLoadBufferEntry({
+            key: recordPath,
+            sessionId,
+            recordPath,
+            lockPath: paths.lockPath,
+            sessionsDir: paths.sessionsDir,
+            indexPath: paths.indexPath,
+            root: paths.root,
+        });
+        const mutated = mutate(entry.record);
+        if (config.getRecordId(mutated) !== sessionId) {
+            throw new SessionRecordMutationError(`Refusing to change session identifier while rewriting history for ${sessionId}.`);
+        }
+        entry.record = mutated;
+        entry.dirty = true;
+        if (forceFlush || config.shouldForceFlush(entry.record)) {
+            await flushBufferEntry(entry, { force: true });
+            await disposeBufferEntry(entry);
+        }
+        else {
+            scheduleBufferFlush(entry);
+        }
+        return mutated;
+    }
+    async function getRecordSnapshot(options) {
+        const { paths, sessionId } = options;
+        const recordPath = join(paths.sessionsDir, sessionId, config.recordFilename);
+        const buffered = buffer.get(recordPath);
+        if (buffered) {
+            return structuredClone(buffered.record);
+        }
+        try {
+            return await readRecordFromDisk(recordPath);
+        }
+        catch (error) {
+            if (error instanceof SessionRecordNotFoundError) {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    async function flushAllRecordBuffers() {
+        const entries = Array.from(buffer.values());
+        for (const entry of entries) {
+            await flushBufferEntry(entry, { force: true });
+            await disposeBufferEntry(entry);
+        }
+    }
+    async function disposeRecordBuffer(options) {
+        const { paths, sessionId } = options;
+        const recordPath = join(paths.sessionsDir, sessionId, config.recordFilename);
+        const entry = buffer.get(recordPath);
+        if (!entry) {
+            return;
+        }
+        await disposeBufferEntry(entry);
+    }
+    async function flushRecordBuffer(options) {
+        const { paths, sessionId } = options;
+        const recordPath = join(paths.sessionsDir, sessionId, config.recordFilename);
+        const entry = buffer.get(recordPath);
+        if (!entry) {
+            return;
+        }
+        await flushBufferEntry(entry, { force: true });
+        await disposeBufferEntry(entry);
+    }
+    function snapshotRecordBuffers() {
+        return Array.from(buffer.values()).map((entry) => ({
+            key: entry.key,
+            sessionId: entry.sessionId,
+            hasFlushTimer: Boolean(entry.flushTimer),
+        }));
+    }
+    function registerBufferEntry(entry) {
+        buffer.set(entry.key, entry);
+    }
+    async function getOrLoadBufferEntry(template) {
+        const existing = buffer.get(template.key);
+        if (existing) {
+            return existing;
+        }
+        const record = await readRecordFromDisk(template.recordPath);
+        const entry = {
+            ...template,
+            record,
+            lastPersistedStatus: config.getRecordStatus(record),
+            dirty: false,
+        };
+        buffer.set(template.key, entry);
+        return entry;
+    }
+    function scheduleBufferFlush(entry) {
+        if (entry.flushTimer) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            entry.flushTimer = undefined;
+            void flushBufferEntry(entry).catch((error) => {
+                console.warn(`[voratiq] Failed to flush session ${entry.sessionId} history: ${error.message}`);
+            });
+        }, BUFFER_FLUSH_DELAY_MS);
+        if (typeof timer.unref === "function") {
+            timer.unref();
+        }
+        entry.flushTimer = timer;
+    }
+    async function flushBufferEntry(entry, options = {}) {
+        const { force = false } = options;
+        if (!entry.dirty && !force) {
+            return;
+        }
+        if (entry.flushPromise) {
+            await entry.flushPromise;
+            return;
+        }
+        if (entry.flushTimer) {
+            clearTimeout(entry.flushTimer);
+            entry.flushTimer = undefined;
+        }
+        await mkdir(entry.sessionsDir, { recursive: true });
+        await mkdir(dirname(entry.recordPath), { recursive: true });
+        const promise = (async () => {
+            const release = await config.acquireLock(entry.lockPath);
+            try {
+                let recordToPersist = entry.record;
+                if (config.mergeRecordOnFlush) {
+                    const diskRecord = await tryReadRecordForMerge(entry);
+                    recordToPersist = config.mergeRecordOnFlush(recordToPersist, diskRecord);
+                    if (config.getRecordId(recordToPersist) !== entry.sessionId) {
+                        throw new SessionRecordMutationError(`Refusing to change session identifier while flushing history for ${entry.sessionId}.`);
+                    }
+                    entry.record = recordToPersist;
+                }
+                await atomicWriteRecord(entry.recordPath, recordToPersist);
+                entry.dirty = false;
+                const currentStatus = config.getRecordStatus(recordToPersist);
+                if (entry.lastPersistedStatus !== currentStatus) {
+                    await upsertIndexEntry(entry.indexPath, config.buildIndexEntry(recordToPersist));
+                    entry.lastPersistedStatus = currentStatus;
+                }
+            }
+            finally {
+                await release();
+            }
+        })();
+        entry.flushPromise = promise;
+        try {
+            await promise;
+        }
+        finally {
+            entry.flushPromise = undefined;
+        }
+    }
+    async function disposeBufferEntry(entry) {
+        const current = buffer.get(entry.key);
+        if (!current || current !== entry) {
+            return;
+        }
+        if (entry.flushTimer) {
+            clearTimeout(entry.flushTimer);
+            entry.flushTimer = undefined;
+        }
+        if (entry.flushPromise) {
+            await entry.flushPromise;
+        }
+        buffer.delete(entry.key);
+    }
+    async function readRecordFromDisk(path) {
+        try {
+            const raw = await readFile(path, "utf8");
+            return config.parseRecord({ path, raw });
+        }
+        catch (error) {
+            if (isFileSystemError(error) && error.code === "ENOENT") {
+                const sessionId = extractIdFromPath(path);
+                throw new SessionRecordNotFoundError(sessionId);
+            }
+            if (error instanceof SyntaxError) {
+                throw new SessionRecordParseError(path, error.message);
+            }
+            throw error;
+        }
+    }
+    async function tryReadRecordForMerge(entry) {
+        try {
+            const raw = await readFile(entry.recordPath, "utf8");
+            return config.parseRecord({ path: entry.recordPath, raw });
+        }
+        catch (error) {
+            if (isFileSystemError(error) && error.code === "ENOENT") {
+                return undefined;
+            }
+            const displayPath = relativeToRoot(entry.root, entry.recordPath);
+            const detail = error instanceof Error
+                ? error.message
+                : typeof error === "string"
+                    ? error
+                    : "unknown error";
+            console.warn(`[voratiq] Failed to read existing session record at ${displayPath} while merging flush for ${entry.sessionId}: ${detail}`);
+            return undefined;
+        }
+    }
+    function extractIdFromPath(path) {
+        if (config.extractIdFromRecordPath) {
+            return config.extractIdFromRecordPath(path);
+        }
+        const segments = path.split(/[/\\]/);
+        const sessionIdIndex = segments.length - 2;
+        return segments[sessionIdIndex] ?? "unknown";
+    }
+    async function atomicWriteRecord(path, payload) {
+        const dir = dirname(path);
+        const tempPath = join(dir, `${randomBytes(8).toString("hex")}.tmp`);
+        const serialized = config.serializeRecord
+            ? config.serializeRecord(payload)
+            : `${JSON.stringify(payload, null, 2)}\n`;
+        await writeFile(tempPath, serialized, { encoding: "utf8" });
+        await rename(tempPath, path);
+    }
+    async function readIndex(path) {
+        try {
+            const raw = await readFile(path, "utf8");
+            const trimmed = raw.trim();
+            if (!trimmed) {
+                return { version: config.indexVersion, sessions: [] };
+            }
+            const parsed = JSON.parse(trimmed);
+            const sessions = config.readIndexEntries
+                ? config.readIndexEntries(parsed)
+                : Array.isArray(parsed.sessions)
+                    ? (parsed.sessions ?? [])
+                    : [];
+            return {
+                version: typeof parsed.version === "number"
+                    ? parsed.version
+                    : config.indexVersion,
+                sessions,
+            };
+        }
+        catch (error) {
+            if (isFileSystemError(error) && error.code === "ENOENT") {
+                return { version: config.indexVersion, sessions: [] };
+            }
+            if (error instanceof SyntaxError) {
+                throw new SessionRecordParseError(path, error.message);
+            }
+            throw error;
+        }
+    }
+    async function upsertIndexEntry(indexPath, entry) {
+        const payload = await readIndex(indexPath);
+        const incomingId = config.getIndexEntryId(entry);
+        const existingIndex = payload.sessions.findIndex((session) => config.getIndexEntryId(session) === incomingId);
+        if (existingIndex >= 0) {
+            const existing = payload.sessions[existingIndex];
+            payload.sessions[existingIndex] = config.mergeIndexEntry
+                ? config.mergeIndexEntry(existing, entry)
+                : { ...existing, ...entry };
+        }
+        else {
+            payload.sessions.push(entry);
+        }
+        payload.version = config.indexVersion;
+        const serializedPayload = config.buildIndexPayload
+            ? config.buildIndexPayload(payload.sessions, payload.version)
+            : { version: payload.version, sessions: payload.sessions };
+        await atomicWriteIndex(indexPath, serializedPayload);
+    }
+    async function atomicWriteIndex(path, payload) {
+        const dir = dirname(path);
+        const tempPath = join(dir, `${randomBytes(8).toString("hex")}.tmp`);
+        const serialized = `${JSON.stringify(payload, null, 2)}\n`;
+        await writeFile(tempPath, serialized, { encoding: "utf8" });
+        await rename(tempPath, path);
+    }
+    return {
+        readRecords,
+        appendRecord,
+        rewriteRecord,
+        getRecordSnapshot,
+        flushAllRecordBuffers,
+        disposeRecordBuffer,
+        flushRecordBuffer,
+        snapshotRecordBuffers,
+        setReadRecordsImplementation,
+        resetReadRecordsImplementation,
+    };
+}

package/dist/policy/auto.d.ts

@@ -0,0 +1,13 @@
+import type { SelectionDecision } from "./result.js";
+export interface AutoVerificationSelectionProceed {
+    kind: "proceed";
+}
+export interface AutoVerificationSelectionActionRequired {
+    kind: "action_required";
+    detail: string;
+}
+export type AutoVerificationSelectionDisposition = AutoVerificationSelectionProceed | AutoVerificationSelectionActionRequired;
+export declare function classifyAutoVerificationSelection(options: {
+    targetKind: "spec" | "run";
+    selection?: SelectionDecision;
+}): AutoVerificationSelectionDisposition;

package/dist/policy/auto.js

@@ -0,0 +1,22 @@
+export function classifyAutoVerificationSelection(options) {
+    const { targetKind, selection } = options;
+    if (selection?.state === "resolvable") {
+        return { kind: "proceed" };
+    }
+    return {
+        kind: "action_required",
+        detail: describeActionRequiredSelection({ targetKind, selection }),
+    };
+}
+function describeActionRequiredSelection(options) {
+    const { targetKind, selection } = options;
+    if (selection?.state === "unresolved" &&
+        selection.unresolvedReasons.some((reason) => reason.code === "verifier_disagreement")) {
+        return targetKind === "spec"
+            ? "Verifiers disagreed on the preferred draft; manual selection required."
+            : "Verifiers disagreed on the preferred candidate; manual selection required.";
+    }
+    return targetKind === "spec"
+        ? "Verification did not select a draft; manual selection required."
+        : "Verification did not produce a resolvable candidate; manual selection required.";
+}

package/dist/policy/index.d.ts

@@ -0,0 +1,5 @@
+export { type AutoVerificationSelectionActionRequired, type AutoVerificationSelectionDisposition, type AutoVerificationSelectionProceed, classifyAutoVerificationSelection, } from "./auto.js";
+export { buildResolvableSelectionDecision, buildUnresolvedSelectionDecision, type ResolvableSelectionDecision, type SelectionDecision, type SelectionDecisionUnresolvedReason, type SelectorResolutionMatch, type UnresolvedSelectionDecision, type VerifierAgreementSelection, } from "./result.js";
+export { deriveSelectorSelectionDecision, type SelectorResolutionInput, type SelectorResolutionSourceInput, } from "./selector.js";
+export { buildVerificationSelectorSource, DEFAULT_VERIFICATION_WINNER_POLICY, deriveVerificationSelectionDecision, loadVerificationPolicyInput, loadVerificationSelectionInput, loadVerificationSelectionPolicyOutput, type StageVerificationUnanimityWinnerPolicy, type VerificationPolicyInput, type VerificationPolicyProgrammaticCandidateInput, type VerificationPolicyProgrammaticInput, type VerificationPolicyRubricInput, type VerificationSelectionInput, type VerificationSelectionPolicyOutput, type VerificationSelectionProgrammaticCandidateInput, type VerificationWinnerPolicy, } from "./verification.js";
+export { deriveVerifierSelectionDecision, type VerifierSelectionReviewerInput, } from "./verifier-selection.js";

package/dist/policy/index.js

@@ -0,0 +1,5 @@
+export { classifyAutoVerificationSelection, } from "./auto.js";
+export { buildResolvableSelectionDecision, buildUnresolvedSelectionDecision, } from "./result.js";
+export { deriveSelectorSelectionDecision, } from "./selector.js";
+export { buildVerificationSelectorSource, DEFAULT_VERIFICATION_WINNER_POLICY, deriveVerificationSelectionDecision, loadVerificationPolicyInput, loadVerificationSelectionInput, loadVerificationSelectionPolicyOutput, } from "./verification.js";
+export { deriveVerifierSelectionDecision, } from "./verifier-selection.js";

package/dist/policy/resolution.d.ts

@@ -0,0 +1,6 @@
+export declare function normalizeCandidateSelector(selector?: string): string | undefined;
+export declare function resolveCanonicalAgentId(options: {
+    selectors: readonly (string | undefined)[];
+    canonicalAgentIds: readonly string[];
+    aliasMap?: Readonly<Record<string, string>>;
+}): string | undefined;

package/dist/policy/resolution.js

@@ -0,0 +1,23 @@
+export function normalizeCandidateSelector(selector) {
+    const normalized = selector?.trim();
+    return normalized && normalized.length > 0 ? normalized : undefined;
+}
+export function resolveCanonicalAgentId(options) {
+    const { selectors, canonicalAgentIds, aliasMap } = options;
+    const canonicalAgentSet = new Set(canonicalAgentIds);
+    for (const selector of selectors) {
+        const normalizedSelector = normalizeCandidateSelector(selector);
+        if (!normalizedSelector) {
+            continue;
+        }
+        if (canonicalAgentSet.has(normalizedSelector)) {
+            return normalizedSelector;
+        }
+        const aliasedCanonicalAgentId = aliasMap?.[normalizedSelector];
+        if (aliasedCanonicalAgentId &&
+            canonicalAgentSet.has(aliasedCanonicalAgentId)) {
+            return aliasedCanonicalAgentId;
+        }
+    }
+    return undefined;
+}

package/dist/policy/result.d.ts

@@ -0,0 +1,53 @@
+export interface VerifierAgreementSelection {
+    verifierAgentId: string;
+    selectedCanonicalAgentId: string;
+}
+export interface SelectorResolutionMatch {
+    sourceId: string;
+    selectedCanonicalAgentId: string;
+}
+export type SelectionDecisionUnresolvedReason = {
+    code: "no_successful_verifiers";
+    failedVerifierAgentIds: readonly string[];
+} | {
+    code: "verifier_failed";
+    failedVerifierAgentIds: readonly string[];
+} | {
+    code: "verifier_preference_missing";
+    verifierAgentId: string;
+} | {
+    code: "verifier_preference_unresolved";
+    verifierAgentId: string;
+    preferredCandidateId?: string;
+    resolvedPreferredCandidateId?: string;
+} | {
+    code: "verifier_disagreement";
+    selections: readonly VerifierAgreementSelection[];
+} | {
+    code: "selector_unresolved";
+    selector: string;
+    availableCanonicalAgentIds: readonly string[];
+    availableAliases: readonly string[];
+} | {
+    code: "selector_ambiguous";
+    selector: string;
+    resolutions: readonly SelectorResolutionMatch[];
+} | {
+    code: "selected_candidate_failed_programmatic";
+    selectedCanonicalAgentId: string;
+    eligibleCanonicalAgentIds: readonly string[];
+};
+export interface ResolvableSelectionDecision {
+    state: "resolvable";
+    applyable: true;
+    selectedCanonicalAgentId: string;
+    unresolvedReasons: readonly [];
+}
+export interface UnresolvedSelectionDecision {
+    state: "unresolved";
+    applyable: false;
+    unresolvedReasons: readonly SelectionDecisionUnresolvedReason[];
+}
+export type SelectionDecision = ResolvableSelectionDecision | UnresolvedSelectionDecision;
+export declare function buildResolvableSelectionDecision(selectedCanonicalAgentId: string): ResolvableSelectionDecision;
+export declare function buildUnresolvedSelectionDecision(unresolvedReasons: readonly SelectionDecisionUnresolvedReason[]): UnresolvedSelectionDecision;

package/dist/policy/result.js

@@ -0,0 +1,15 @@
+export function buildResolvableSelectionDecision(selectedCanonicalAgentId) {
+    return {
+        state: "resolvable",
+        applyable: true,
+        selectedCanonicalAgentId,
+        unresolvedReasons: [],
+    };
+}
+export function buildUnresolvedSelectionDecision(unresolvedReasons) {
+    return {
+        state: "unresolved",
+        applyable: false,
+        unresolvedReasons,
+    };
+}

package/dist/policy/selector.d.ts

@@ -0,0 +1,11 @@
+import { type SelectionDecision } from "./result.js";
+export interface SelectorResolutionSourceInput {
+    sourceId: string;
+    aliasMap: Readonly<Record<string, string>>;
+}
+export interface SelectorResolutionInput {
+    selector: string;
+    canonicalAgentIds: readonly string[];
+    sources: readonly SelectorResolutionSourceInput[];
+}
+export declare function deriveSelectorSelectionDecision(input: SelectorResolutionInput): SelectionDecision;

package/dist/policy/selector.js

@@ -0,0 +1,57 @@
+import { normalizeCandidateSelector, resolveCanonicalAgentId, } from "./resolution.js";
+import { buildResolvableSelectionDecision, buildUnresolvedSelectionDecision, } from "./result.js";
+export function deriveSelectorSelectionDecision(input) {
+    const selector = normalizeCandidateSelector(input.selector) ?? "";
+    const canonicalMatch = resolveCanonicalAgentId({
+        selectors: [selector],
+        canonicalAgentIds: input.canonicalAgentIds,
+    });
+    if (canonicalMatch) {
+        return buildResolvableSelectionDecision(canonicalMatch);
+    }
+    const availableAliases = new Set();
+    const matchesByKey = new Map();
+    for (const source of input.sources) {
+        for (const alias of Object.keys(source.aliasMap)) {
+            availableAliases.add(alias);
+        }
+        const selectedCanonicalAgentId = resolveCanonicalAgentId({
+            selectors: [selector],
+            canonicalAgentIds: input.canonicalAgentIds,
+            aliasMap: source.aliasMap,
+        });
+        if (!selectedCanonicalAgentId) {
+            continue;
+        }
+        const match = {
+            sourceId: source.sourceId,
+            selectedCanonicalAgentId,
+        };
+        matchesByKey.set(`${match.sourceId}:${match.selectedCanonicalAgentId}`, match);
+    }
+    const matches = Array.from(matchesByKey.values()).sort((left, right) => left.sourceId.localeCompare(right.sourceId));
+    const uniqueMatches = new Set(matches.map((match) => match.selectedCanonicalAgentId));
+    if (uniqueMatches.size === 1) {
+        const selectedCanonicalAgentId = matches[0]?.selectedCanonicalAgentId;
+        if (selectedCanonicalAgentId) {
+            return buildResolvableSelectionDecision(selectedCanonicalAgentId);
+        }
+    }
+    if (uniqueMatches.size > 1) {
+        return buildUnresolvedSelectionDecision([
+            {
+                code: "selector_ambiguous",
+                selector,
+                resolutions: matches,
+            },
+        ]);
+    }
+    return buildUnresolvedSelectionDecision([
+        {
+            code: "selector_unresolved",
+            selector,
+            availableCanonicalAgentIds: [...input.canonicalAgentIds],
+            availableAliases: Array.from(availableAliases).sort((left, right) => left.localeCompare(right)),
+        },
+    ]);
+}