return /\/actions\/runs\/(\d+)/u.exec(output)?.[1];

}

type WorkflowRunListEntry = {

createdAt?: string;

created_at?: string;

databaseId?: number | string;

id?: number | string;

};

function normalizeRunId(value: unknown): string | undefined {

if (typeof value === "number" && Number.isFinite(value)) {

return String(value);

}

if (typeof value === "string" && value.trim()) {

return value.trim();

}

return undefined;

}

export function selectNewestDispatchedRunId(params: {

beforeIds: ReadonlySet<string>;

runs: readonly WorkflowRunListEntry[];

}): string | undefined {

return params.runs

.filter((entry) => {

const id = normalizeRunId(entry.databaseId ?? entry.id);

return id !== undefined && !params.beforeIds.has(id);

})

.toSorted((a, b) =>

(b.createdAt ?? b.created_at ?? "").localeCompare(a.createdAt ?? a.created_at ?? ""),

)

.map((entry) => normalizeRunId(entry.databaseId ?? entry.id))

.find((id): id is string => id !== undefined);

}

function listWorkflowDispatchRuns(repo: string, workflow: string): WorkflowRunListEntry[] {

const encodedWorkflow = encodeURIComponent(workflow);

const response = ghJson(

repo,

`actions/workflows/${encodedWorkflow}/runs?event=workflow_dispatch&per_page=50`,

) as { workflow_runs?: WorkflowRunListEntry[] };

return response.workflow_runs ?? [];

}

async function findDispatchedWorkflowRunId(params: {

beforeIds: ReadonlySet<string>;

repo: string;

workflow: string;

}): Promise<string> {

for (let attempt = 0; attempt < 60; attempt++) {

const runId = selectNewestDispatchedRunId({

beforeIds: params.beforeIds,

runs: listWorkflowDispatchRuns(params.repo, params.workflow),

});

if (runId) {

return runId;

}

await new Promise((resolve) => {

setTimeout(resolve, 5_000);

});

export function requireWorkflowRunIdFromOutput(output: string, workflow: string): string {

const runId = parseWorkflowRunIdFromOutput(output);

if (!runId) {

throw new Error(

`gh workflow run ${workflow} did not return an Actions run URL; refusing to guess from recent workflow_dispatch runs`,

);

}

throw new Error(`could not find dispatched run for ${params.workflow}`);

return runId;

}

async function dispatchTelegram(options: Options, packageSpec: string): Promise<string> {

const beforeIds = new Set(

listWorkflowDispatchRuns(options.repo, TELEGRAM_BETA_WORKFLOW_FILE)

.map((entry) => normalizeRunId(entry.databaseId ?? entry.id))

.filter((id): id is string => id !== undefined),

);

const output = run(

"gh",

[

],

{ capture: true },

);

const runId = parseWorkflowRunIdFromOutput(output);

if (runId) {

return runId;

}

return await findDispatchedWorkflowRunId({

beforeIds,

repo: options.repo,

workflow: TELEGRAM_BETA_WORKFLOW_FILE,

});

return requireWorkflowRunIdFromOutput(output, TELEGRAM_BETA_WORKFLOW_FILE);

}

export async function pollRun(

}

if (!options.skipParallels) {

runParallels(options.beta, options.model);

runParallels(version, options.model);

}

if (telegramRunId) {