@work-graph/cli 0.2.0

package/vendor/src/intentRoadmapEpicProjection.mjs

@@ -0,0 +1,122 @@
+import {
+  attachDerivedWorkItemHierarchy,
+  DONE_STATUSES,
+  readWorkItemKind,
+  summarizeWorkItemHierarchyRollup,
+} from './workItemHierarchy.mjs';
+import { buildEpicRoadmapCanvasModel } from './intentRoadmapCanvas.mjs';
+
+export const EPIC_ROADMAP_PROJECTION_SCHEMA = 'workgraph.roadmap-epics.projection.v1';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+function computeChildRollup(children) {
+  let closed = 0;
+  let blocked = 0;
+  let inProgress = 0;
+
+  for (const child of children) {
+    const status = String(child.status ?? '').trim().toLowerCase();
+    if (DONE_STATUSES.has(status)) {
+      closed += 1;
+    } else if (status === 'blocked') {
+      blocked += 1;
+    } else {
+      inProgress += 1;
+    }
+  }
+
+  return {
+    closed,
+    total: children.length,
+    blocked,
+    inProgress,
+  };
+}
+
+function buildEpicChildNode(item) {
+  return {
+    workId: item.id,
+    title: item.title ?? item.id,
+    status: item.status ?? '',
+    itemKind: readWorkItemKind(item),
+  };
+}
+
+function buildEpicEntry(epic, itemById) {
+  const childItems = (epic.childIds ?? [])
+    .map((childId) => itemById.get(childId))
+    .filter(Boolean)
+    .sort((left, right) => compareText(left.id, right.id));
+
+  const hierarchyRollup = summarizeWorkItemHierarchyRollup(epic, [...itemById.values()]);
+  const rollup = computeChildRollup(childItems);
+
+  return {
+    epicId: epic.id,
+    title: epic.title ?? epic.id,
+    status: epic.status ?? '',
+    childCount: hierarchyRollup.childCount,
+    doneChildCount: hierarchyRollup.doneChildCount,
+    closeBlocked: hierarchyRollup.closeBlocked,
+    rollup,
+    children: childItems.map(buildEpicChildNode),
+  };
+}
+
+function parseCollapsedEpicIds(value) {
+  if (value instanceof Set) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return new Set(value.map((entry) => String(entry).trim()).filter(Boolean));
+  }
+  const raw = String(value ?? '').trim();
+  if (raw === '') {
+    return new Set();
+  }
+  return new Set(raw.split(',').map((entry) => entry.trim()).filter(Boolean));
+}
+
+function isActiveEpic(epic, hierarchyRollup) {
+  const status = String(epic.status ?? '').trim().toLowerCase();
+  return !DONE_STATUSES.has(status) || hierarchyRollup.closeBlocked;
+}
+
+/**
+ * @param {Array<object>} workItems
+ * @param {{ active?: boolean, withChildren?: boolean, collapsed?: Set<string>|string[]|string, cwd?: string }} [options]
+ */
+export function buildEpicRoadmapProjection(workItems, options = {}) {
+  const enriched = attachDerivedWorkItemHierarchy(workItems);
+  const itemById = new Map(enriched.map((item) => [item.id, item]));
+  const collapsedEpicIds = parseCollapsedEpicIds(options.collapsed);
+
+  let epics = enriched.filter((item) => readWorkItemKind(item) === 'epic');
+
+  if (options.active === true) {
+    epics = epics.filter((epic) => isActiveEpic(epic, summarizeWorkItemHierarchyRollup(epic, enriched)));
+  }
+
+  if (options.withChildren === true) {
+    epics = epics.filter((epic) => (epic.childIds ?? []).length > 0);
+  }
+
+  const entries = epics
+    .map((epic) => buildEpicEntry(epic, itemById))
+    .sort((left, right) => compareText(left.epicId, right.epicId));
+
+  const canvasOptions = { collapsedEpicIds };
+
+  return {
+    schema: EPIC_ROADMAP_PROJECTION_SCHEMA,
+    readOnly: true,
+    epicCount: entries.length,
+    epics: entries.map((entry) => ({
+      ...entry,
+      canvas: buildEpicRoadmapCanvasModel(entry, canvasOptions),
+    })),
+  };
+}
+
+export { parseCollapsedEpicIds };

package/vendor/src/intentRoadmapMermaid.mjs

@@ -0,0 +1,165 @@
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+
+export const INTENT_ROADMAP_MERMAID_SCHEMA = 'workgraph.intent-roadmap.mermaid.v1';
+
+function sanitizeMermaidId(raw) {
+  return String(raw).replace(/[^a-zA-Z0-9_]/gu, '_').replace(/_+/gu, '_').replace(/^_|_$/gu, '') || 'node';
+}
+
+function mermaidNodeId(kind, rawId) {
+  return `${kind}_${sanitizeMermaidId(rawId)}`;
+}
+
+function escapeMermaidLabel(text, maxLen = 72) {
+  const cleaned = String(text ?? '')
+    .replace(/"/gu, "'")
+    .replace(/[\[\]{}#;|]/gu, ' ')
+    .replace(/\s+/gu, ' ')
+    .trim();
+  if (cleaned.length <= maxLen) {
+    return cleaned;
+  }
+  return `${cleaned.slice(0, maxLen - 1)}…`;
+}
+
+function analyticsTitleFromRef(analyticsRef) {
+  const ref = String(analyticsRef ?? '').trim();
+  if (ref === '') {
+    return 'Анализ';
+  }
+  const slug = ref.replace(/^analytics:/u, '');
+  return `Анализ ${slug}`;
+}
+
+export function findAllOptionsForQuestion(question, intentNodes) {
+  if (!question) {
+    return [];
+  }
+  return intentNodes
+    .filter((node) => node.nodeKind === 'option' && node.parentId === question.id)
+    .sort((left, right) => compareText(left.id, right.id));
+}
+
+function workNodeLabel(node) {
+  const done = node.status === 'done' || node.status === 'verified';
+  const progress = node.childCount > 0 ? ` (${node.doneChildCount}/${node.childCount})` : '';
+  const suffix = done ? ' · done' : '';
+  return escapeMermaidLabel(`${node.title ?? node.workId}${progress}${suffix}`);
+}
+
+function appendWorkTreeLines(lines, node, epicId, classNames) {
+  const taskId = mermaidNodeId('task', node.workId);
+  lines.push(`  ${epicId} --> ${taskId}["${workNodeLabel(node)}"]`);
+  classNames.push(`${taskId}${doneClass(node.status)}`);
+
+  for (const child of node.children ?? []) {
+    appendWorkTreeLines(lines, child, taskId, classNames);
+  }
+}
+
+function doneClass(status) {
+  return status === 'done' || status === 'verified' ? ':::done' : '';
+}
+
+/**
+ * @param {{
+ *   decisionId: string,
+ *   decisionTitle?: string,
+ *   analyticsRef?: string,
+ *   question?: { id: string, title?: string } | null,
+ *   selectedOption?: { id: string, title?: string } | null,
+ *   decision?: { id: string, title?: string } | null,
+ *   allOptions?: Array<{ id: string, title?: string, selected?: boolean }>,
+ *   roots?: Array<object>,
+ * }} branch
+ */
+export function buildIntentRoadmapMermaidSource(branch) {
+  const lines = ['flowchart TB'];
+  const classLines = [];
+  const classNames = [];
+
+  const question = branch.question;
+  const decision = branch.decision ?? { id: branch.decisionId, title: branch.decisionTitle };
+  const selectedOptionId = branch.selectedOption?.id ?? '';
+  const allOptions = branch.allOptions ?? (branch.selectedOption ? [branch.selectedOption] : []);
+
+  let anchorId = null;
+
+  if (question) {
+    const questionId = mermaidNodeId('q', question.id);
+    lines.push(`  ${questionId}["${escapeMermaidLabel(question.title ?? question.id)}"]`);
+    classNames.push(`${questionId}:::question`);
+    anchorId = questionId;
+  }
+
+  if (branch.analyticsRef) {
+    const analysisId = mermaidNodeId('an', branch.analyticsRef);
+    lines.push(`  ${analysisId}["${escapeMermaidLabel(analyticsTitleFromRef(branch.analyticsRef))}"]`);
+    classNames.push(`${analysisId}:::analysis`);
+    if (anchorId) {
+      lines.push(`  ${anchorId} --> ${analysisId}`);
+    }
+    anchorId = analysisId;
+  }
+
+  const optionIds = new Map();
+  for (const option of allOptions) {
+    const optionId = mermaidNodeId('opt', option.id);
+    optionIds.set(option.id, optionId);
+    const selected = option.id === selectedOptionId || option.selected === true;
+    lines.push(`  ${optionId}["${escapeMermaidLabel(option.title ?? option.id)}"]`);
+    classNames.push(`${optionId}${selected ? ':::selected' : ':::rejected'}`);
+    if (anchorId) {
+      lines.push(`  ${anchorId} --> ${optionId}`);
+    }
+  }
+
+  const decisionId = mermaidNodeId('dec', decision.id ?? branch.decisionId);
+  lines.push(`  ${decisionId}["${escapeMermaidLabel(decision.title ?? branch.decisionTitle ?? branch.decisionId)}"]`);
+  classNames.push(`${decisionId}:::decision`);
+
+  if (selectedOptionId && optionIds.has(selectedOptionId)) {
+    lines.push(`  ${optionIds.get(selectedOptionId)} --> ${decisionId}`);
+  } else if (anchorId) {
+    lines.push(`  ${anchorId} --> ${decisionId}`);
+  }
+
+  for (const root of branch.roots ?? []) {
+    const epicId = mermaidNodeId('epic', root.workId);
+    lines.push(`  ${decisionId} --> ${epicId}["${workNodeLabel(root)}"]`);
+    classNames.push(`${epicId}${doneClass(root.status)}`);
+
+    for (const child of root.children ?? []) {
+      appendWorkTreeLines(lines, child, epicId, classNames);
+    }
+  }
+
+  lines.push('');
+  lines.push('  classDef question fill:#f4f5f7,stroke:#6554c0,color:#172b4d');
+  lines.push('  classDef analysis fill:#f4f5f7,stroke:#5e6c84,color:#172b4d');
+  lines.push('  classDef selected fill:#deebff,stroke:#0052cc,color:#172b4d');
+  lines.push('  classDef rejected fill:#fafbfc,stroke:#c1c7d0,color:#5e6c84,stroke-dasharray:4 3');
+  lines.push('  classDef decision fill:#e3fcef,stroke:#00875a,color:#172b4d');
+  lines.push('  classDef done fill:#e3fcef,stroke:#00875a,color:#172b4d');
+  lines.push(`  ${classNames.join('\n  ')}`);
+
+  const source = lines.join('\n');
+  return {
+    schema: INTENT_ROADMAP_MERMAID_SCHEMA,
+    source,
+  };
+}
+
+export function enrichIntentRoadmapBranchWithMermaid(branch, intentNodes) {
+  const allOptions = findAllOptionsForQuestion(branch.question, intentNodes);
+  const enriched = {
+    ...branch,
+    allOptions: allOptions.map((option) => ({
+      id: option.id,
+      title: option.title,
+      selected: option.id === branch.selectedOption?.id || option.selected === true,
+    })),
+  };
+  enriched.mermaid = buildIntentRoadmapMermaidSource(enriched);
+  return enriched;
+}

package/vendor/src/intentRoadmapProjection.mjs

@@ -0,0 +1,85 @@
+import { attachDerivedWorkItemHierarchy, readWorkItemKind } from './workItemHierarchy.mjs';
+import { buildIntentGraphProjection, resolveIntentBranchForAnalyticsRecord } from './intentGraphProjection.mjs';
+import { enrichIntentRoadmapBranchWithCanvas } from './intentRoadmapCanvas.mjs';
+import { parseCollapsedEpicIds } from './intentRoadmapEpicProjection.mjs';
+
+export const INTENT_ROADMAP_PROJECTION_SCHEMA = 'workgraph.intent-roadmap.projection.v1';
+
+const compareText = (left, right) => String(left).localeCompare(String(right), 'en', { sensitivity: 'variant' });
+const DONE_STATUSES = new Set(['done', 'verified']);
+
+function buildRoadmapBranch(decision, intentGraph, workItems) {
+  const decisionId = decision.id;
+  const roots = workItems.filter((item) => {
+    const labels = item.labels ?? {};
+    return String(labels['intent.decision_id'] ?? '').trim() === decisionId
+      && readWorkItemParentId(item) === '';
+  });
+
+  const buildNode = (item) => {
+    const childItems = (item.childIds ?? [])
+      .map((childId) => workItems.find((candidate) => candidate.id === childId))
+      .filter(Boolean);
+
+    const doneChildCount = childItems.filter((child) => DONE_STATUSES.has(child.status)).length;
+
+    return {
+      workId: item.id,
+      title: item.title ?? item.id,
+      status: item.status ?? '',
+      parentId: item.parentId ?? '',
+      itemKind: readWorkItemKind(item),
+      childCount: childItems.length,
+      doneChildCount,
+      closeBlocked: childItems.length > 0 && doneChildCount < childItems.length,
+      children: childItems.map(buildNode).sort((left, right) => compareText(left.workId, right.workId)),
+    };
+  };
+
+  return {
+    decisionId,
+    decisionTitle: decision.title ?? decisionId,
+    analyticsRef: decision.links?.analytics_ref ?? '',
+    roots: roots.map(buildNode).sort((left, right) => compareText(left.workId, right.workId)),
+  };
+}
+
+function readWorkItemParentId(item) {
+  return String(item.parentId ?? item.labels?.['work.parent_id'] ?? '').trim();
+}
+
+export function buildIntentRoadmapProjection(intentNodes, workItems, options = {}) {
+  const intentGraph = buildIntentGraphProjection(intentNodes, workItems, options);
+  const enrichedWorkItems = attachDerivedWorkItemHierarchy(workItems);
+  const selectedDecisions = intentGraph.nodes.filter((node) => node.nodeKind === 'decision' && node.selected === true);
+  const canvasOptions = {
+    collapsedEpicIds: parseCollapsedEpicIds(options.collapsed),
+  };
+
+  const branches = selectedDecisions.map((decision) =>
+    enrichIntentRoadmapBranchWithCanvas(
+      buildRoadmapBranch(decision, intentGraph, enrichedWorkItems),
+      intentGraph.nodes,
+      canvasOptions,
+    ),
+  ).sort((left, right) => compareText(left.decisionId, right.decisionId));
+
+  return {
+    schema: INTENT_ROADMAP_PROJECTION_SCHEMA,
+    readOnly: true,
+    branchCount: branches.length,
+    branches,
+    intentGraphSchema: intentGraph.schema,
+  };
+}
+
+export function buildIntentRoadmapForAnalyticsRecord(record, intentNodes, workItems) {
+  const intentGraph = buildIntentGraphProjection(intentNodes, workItems);
+  const branch = resolveIntentBranchForAnalyticsRecord(record, intentGraph);
+  if (!branch?.selectedDecision) {
+    return null;
+  }
+
+  const projection = buildIntentRoadmapProjection(intentNodes, workItems);
+  return projection.branches.find((entry) => entry.decisionId === branch.selectedDecision.id) ?? null;
+}

package/vendor/src/intentTreeLint.mjs

@@ -0,0 +1,114 @@
+import { access, readdir } from 'node:fs/promises';
+import { join, posix } from 'node:path';
+
+import { parseIntentIndexEntries } from './intentTreeWorkItems.mjs';
+import { isWorkItemArtifactPath, workItemPathMatchesId } from './bvcNewWritePolicy.mjs';
+
+export const INTENT_TREE_LINT_SCHEMA = 'workgraph.intent-tree.lint.v1';
+
+async function fileExists(absolutePath) {
+  try {
+    await access(absolutePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function listIntentWorkStepFiles(rootDir, cwd) {
+  const entries = await readdir(rootDir, { withFileTypes: true });
+  const nested = await Promise.all(
+    entries.map(async (entry) => {
+      const entryPath = join(rootDir, entry.name);
+      if (entry.isDirectory()) {
+        return listIntentWorkStepFiles(entryPath, cwd);
+      }
+
+      return entry.isFile() && isWorkItemArtifactPath(entry.name) ? [entryPath] : [];
+    }),
+  );
+
+  return nested.flat();
+}
+
+function toRepoRelativePath(cwd, absolutePath) {
+  return absolutePath
+    .slice(cwd.length + 1)
+    .split(/\\/u)
+    .join('/');
+}
+
+/**
+ * @param {{ cwd?: string, intentRoot?: string, indexPath?: string, indexText?: string }} [options]
+ */
+export async function lintIntentTreeOrphans(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const intentRoot = join(cwd, options.intentRoot ?? 'intent');
+  const indexPath = options.indexPath ?? 'intent/index.bvc';
+  const { readFile } = await import('node:fs/promises');
+  const indexText = options.indexText ?? await readFile(join(cwd, indexPath), 'utf8');
+  const indexEntries = parseIntentIndexEntries(indexText);
+  const indexById = new Map(indexEntries.map((entry) => [entry.id, entry.path]));
+  const indexPaths = new Set(indexEntries.map((entry) => entry.path.replace(/\\/g, '/')));
+
+  const diskFiles = await listIntentWorkStepFiles(intentRoot, cwd);
+  const diskPaths = diskFiles.map((filePath) => toRepoRelativePath(cwd, filePath));
+
+  const orphanFiles = diskPaths
+    .filter((relativePath) => !indexPaths.has(relativePath))
+    .sort()
+    .map((path) => ({ path, kind: 'orphan_file' }));
+
+  const missingFiles = [];
+  const workIdMismatches = [];
+
+  for (const entry of indexEntries) {
+    const normalizedPath = entry.path.replace(/\\/g, '/');
+    const absolutePath = join(cwd, normalizedPath);
+    const exists = await fileExists(absolutePath);
+
+    if (!exists) {
+      missingFiles.push({
+        workId: entry.id,
+        path: normalizedPath,
+        kind: 'missing_file',
+      });
+      continue;
+    }
+
+    if (!workItemPathMatchesId(entry.id, normalizedPath)) {
+      workIdMismatches.push({
+        workId: entry.id,
+        path: normalizedPath,
+        kind: 'path_work_id_mismatch',
+        expectedSuffix: `${entry.id}.work.bvc (or legacy .work.bvc)`,
+      });
+    }
+  }
+
+  const indexedIds = new Set(indexEntries.map((entry) => entry.id));
+  const duplicateIds = indexEntries
+    .map((entry) => entry.id)
+    .filter((id, index, array) => array.indexOf(id) !== index);
+
+  const errors = [
+    ...orphanFiles.map((row) => `orphan work item file without index entry: ${row.path}`),
+    ...missingFiles.map((row) => `index entry without file: ${row.workId} -> ${row.path}`),
+    ...workIdMismatches.map((row) => `index path mismatch for ${row.workId}: ${row.path}`),
+    ...duplicateIds.map((id) => `duplicate index work.id: ${id}`),
+  ];
+
+  return {
+    schema: INTENT_TREE_LINT_SCHEMA,
+    ok: errors.length === 0,
+    indexPath,
+    indexedCount: indexEntries.length,
+    diskFileCount: diskPaths.length,
+    orphanFiles,
+    missingFiles,
+    workIdMismatches,
+    duplicateIndexIds: [...new Set(duplicateIds)].sort(),
+    errors,
+    indexById: Object.fromEntries(indexById),
+  };
+}

package/vendor/src/intentTreeMigration.mjs

@@ -0,0 +1,150 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, posix } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { buildSnapshot, parseWorkItems } from './workGraphRuntime.mjs';
+import { classifyIntentFolder, toIntentPath } from './intentHierarchy.mjs';
+
+const STEP_ATOM_PATTERN = /^#([^\n<]+)<\[\n([\s\S]*?)\n\]>/gmu;
+
+export function extractWorkItemAtoms(backlogText) {
+  if (typeof backlogText !== 'string') {
+    throw new TypeError('backlogText must be a string');
+  }
+
+  return [...backlogText.matchAll(STEP_ATOM_PATTERN)]
+    .map((match) => {
+      const [content] = match;
+      const [item] = parseWorkItems(content);
+      return item ? { item, content: ensureTrailingNewline(content) } : null;
+    })
+    .filter(Boolean);
+}
+
+export function buildIntentTreeEntries(backlogText) {
+  const entries = extractWorkItemAtoms(backlogText).map(({ item, content }) => ({
+    id: item.id,
+    path: toIntentPathFromItem(item),
+    content,
+    item,
+  }));
+
+  assertUniquePaths(entries);
+  return entries.sort((left, right) => compareText(left.id, right.id));
+}
+
+export function buildIntentIndexStep(entries) {
+  const lines = entries
+    .map((entry) => `  - ${entry.id}: ${toPortablePath(entry.path)}`)
+    .join('\n');
+
+  return `#Индекс_Intent_Tree_WorkItems<[
+Базис:
+  Generated compatibility manifest for WorkItem atoms split from work/backlog.bvc.
+Вектор:
+  Keep work/backlog.bvc intact for current runtime/UI readers until they can read intent/**/*.work.bvc directly.
+Цель:
+  Provide a deterministic inventory of canonical intent tree task files without changing current backlog compatibility.
+WorkItems:
+${lines}
+
+Метки:
+  atom.profile: trace
+  intent.index: work_items
+  intent.source: work/backlog.bvc
+  intent.compatibility_projection: work/backlog.bvc
+  trace.status: pending
+]>
+`;
+}
+
+export function compareBacklogAndIntentSnapshots(backlogText, intentFileTexts) {
+  const backlogSnapshot = buildSnapshot(parseWorkItems(backlogText));
+  const intentSnapshot = buildSnapshot(parseWorkItems(intentFileTexts.join('\n')));
+
+  return {
+    equal: JSON.stringify(backlogSnapshot) === JSON.stringify(intentSnapshot),
+    backlogSnapshot,
+    intentSnapshot,
+  };
+}
+
+export async function writeIntentTreeFromBacklog(backlogText, options = {}) {
+  const root = options.root ?? process.cwd();
+  if (options.clean === true) {
+    await rm(join(root, 'intent'), { recursive: true, force: true });
+  }
+
+  const entries = buildIntentTreeEntries(backlogText);
+
+  for (const entry of entries) {
+    const absolutePath = join(root, entry.path);
+    await mkdir(dirname(absolutePath), { recursive: true });
+    await writeFile(absolutePath, entry.content, 'utf8');
+  }
+
+  const indexPath = options.indexPath ?? 'intent/index.bvc';
+  await mkdir(dirname(join(root, indexPath)), { recursive: true });
+  await writeFile(join(root, indexPath), buildIntentIndexStep(entries), 'utf8');
+
+  const comparison = compareBacklogAndIntentSnapshots(
+    backlogText,
+    entries.map((entry) => entry.content),
+  );
+
+  return {
+    entries,
+    indexPath,
+    comparison,
+  };
+}
+
+function toIntentPathFromItem(item) {
+  return toIntentPath(item);
+}
+
+function assertUniquePaths(entries) {
+  const seen = new Map();
+
+  for (const entry of entries) {
+    const existing = seen.get(entry.path);
+    if (existing !== undefined) {
+      throw new Error(`duplicate intent path ${entry.path} for ${existing} and ${entry.id}`);
+    }
+
+    seen.set(entry.path, entry.id);
+  }
+}
+
+function toPortablePath(path) {
+  return path;
+}
+
+function ensureTrailingNewline(text) {
+  return text.endsWith('\n') ? text : `${text}\n`;
+}
+
+function compareText(left, right) {
+  return left.localeCompare(right, 'en', { sensitivity: 'variant' });
+}
+
+export { lintIntentTreeOrphans } from './intentTreeLint.mjs';
+
+async function main() {
+  const { readFile } = await import('node:fs/promises');
+  const root = process.cwd();
+  const backlogPath = join(root, 'work/backlog.bvc');
+  const backlogText = await readFile(backlogPath, 'utf8');
+  const result = await writeIntentTreeFromBacklog(backlogText, { root, clean: true });
+
+  if (!result.comparison.equal) {
+    throw new Error('intent tree split did not preserve backlog snapshot');
+  }
+
+  console.log(`Wrote ${result.entries.length} WorkItem files and ${result.indexPath}`);
+}
+
+const invokedUrl = process.argv[1] ? pathToFileURL(process.argv[1]).href : '';
+if (invokedUrl === import.meta.url) {
+  await main();
+}