@konitif/workbench 0.284.1

package/dist/domain/repo-quality/model.d.ts

@@ -0,0 +1,111 @@
+export type RepoQualityDimensionId = 'tests' | 'docs' | 'decoupling';
+export type RepoQualityGranularity = 'repo' | 'workspace' | 'file';
+export type RepoQualityStatus = 'covered' | 'partial' | 'missing' | 'risk';
+export interface RepoQualityDimensionScore {
+    id: RepoQualityDimensionId;
+    label: string;
+    score: number;
+    status: RepoQualityStatus;
+    total: number;
+    covered: number;
+    partial: number;
+    missing: number;
+    risk: number;
+}
+export interface RepoQualityRule {
+    id: string;
+    dimension: RepoQualityDimensionId;
+    label: string;
+    summary: string;
+    targetScore: number;
+    severity: 'info' | 'warning' | 'error';
+}
+export interface RepoQualityEvidence {
+    kind: 'test' | 'doc' | 'source';
+    path: string;
+    confidence: 'direct' | 'related' | 'inferred';
+}
+export interface RepoQualityFileEvaluation {
+    id: string;
+    granularity: 'file';
+    path: string;
+    owner: string;
+    layer: string;
+    kind: string;
+    lineCount: number;
+    importCount: number;
+    exportedSymbolCount: number;
+    scores: Record<RepoQualityDimensionId, number>;
+    statuses: Record<RepoQualityDimensionId, RepoQualityStatus>;
+    evidences: RepoQualityEvidence[];
+    findings: string[];
+}
+export interface RepoQualityCoverageSummary {
+    sourceFiles: number;
+    testEvidenceFiles: number;
+    docEvidenceFiles: number;
+    fullyCoveredFiles: number;
+    score: number;
+    status: RepoQualityStatus;
+}
+export interface RepoQualityWorkspaceEvaluation {
+    id: string;
+    granularity: 'workspace';
+    path: string;
+    fileCount: number;
+    lineCount: number;
+    coverage: RepoQualityCoverageSummary;
+    scores: Record<RepoQualityDimensionId, number>;
+    statuses: Record<RepoQualityDimensionId, RepoQualityStatus>;
+    riskCount: number;
+    missingCount: number;
+    findings: string[];
+}
+export interface RepoQualityEntryRootEvaluation {
+    id: string;
+    path: string;
+    kind: 'app' | 'package' | 'tooling';
+    sourceFileCount: number;
+    lineCount: number;
+    coverage: RepoQualityCoverageSummary;
+    status: RepoQualityStatus;
+    findings: string[];
+}
+export interface RepoQualityHistorySnapshot {
+    step: number;
+    generatedAt: string;
+    totals: {
+        sourceFiles: number;
+        sourceLines: number;
+        workspaces: number;
+        entryRoots: number;
+    };
+    dimensions: Record<RepoQualityDimensionId, {
+        score: number;
+        status: RepoQualityStatus;
+        total: number;
+        covered: number;
+        partial: number;
+        missing: number;
+        risk: number;
+    }>;
+}
+export interface RepoQualityEvaluation {
+    schemaVersion: 'repo-quality-evaluation.v1';
+    generatedAt: string;
+    repoRoot: string;
+    rules: RepoQualityRule[];
+    totals: {
+        sourceFiles: number;
+        testFiles: number;
+        docFiles: number;
+        workspaces: number;
+        entryRoots: number;
+        sourceLines: number;
+    };
+    dimensions: RepoQualityDimensionScore[];
+    entryRoots: RepoQualityEntryRootEvaluation[];
+    workspaces: RepoQualityWorkspaceEvaluation[];
+    files: RepoQualityFileEvaluation[];
+    history: RepoQualityHistorySnapshot[];
+}

package/dist/domain/repo-quality/model.js

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

package/dist/domain/repository/model.d.ts

@@ -0,0 +1,110 @@
+export type RepositoryPackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun' | 'unknown';
+export type RepositoryInspectionSeverity = 'info' | 'warning' | 'blocked';
+export type RepositoryFramework = 'svelte' | 'react' | 'vue' | 'solid' | 'unknown';
+export type RepositoryBuildTool = 'vite' | 'sveltekit' | 'next' | 'nuxt' | 'vitest' | 'playwright' | 'typescript' | 'unknown';
+export type RepositoryScriptKind = 'dev' | 'build' | 'test' | 'lint' | 'format' | 'preview' | 'check' | 'other';
+export interface RepositoryInspectionFinding {
+    id: string;
+    severity: RepositoryInspectionSeverity;
+    title: string;
+    message: string;
+}
+export interface RepositoryScriptSnapshot {
+    name: string;
+    command: string;
+    kind: RepositoryScriptKind;
+}
+export interface RepositoryWorkspaceSnapshot {
+    patterns: string[];
+}
+export interface RepositoryGitSnapshot {
+    branch: string | null;
+    commit: string | null;
+    dirty: boolean;
+}
+export interface RepositoryInspectionSummary {
+    primaryFramework: RepositoryFramework;
+    primaryBuildTool: RepositoryBuildTool;
+    launchCommand: string | null;
+    testCommand: string | null;
+    scriptKinds: RepositoryScriptKind[];
+    configCount: number;
+    workspacePackageCount: number;
+}
+export interface RepositoryInspectionSnapshot {
+    id: string;
+    label: string;
+    root: string;
+    generatedAt: string;
+    packageName: string | null;
+    packageVersion: string | null;
+    packageManager: RepositoryPackageManager;
+    frameworks: RepositoryFramework[];
+    buildTools: RepositoryBuildTool[];
+    scripts: RepositoryScriptSnapshot[];
+    workspaces: RepositoryWorkspaceSnapshot | null;
+    git: RepositoryGitSnapshot | null;
+    configs: string[];
+    summary: RepositoryInspectionSummary;
+    findings: RepositoryInspectionFinding[];
+    inspectOnly: boolean;
+    canLaunch: boolean;
+}
+export interface RepositoryInspectionInput {
+    label?: string | null;
+    root: string;
+    files?: string[];
+    packageJson?: {
+        name?: string;
+        version?: string;
+        scripts?: Record<string, string>;
+        workspaces?: string[] | {
+            packages?: string[];
+        };
+        dependencies?: Record<string, string>;
+        devDependencies?: Record<string, string>;
+    } | null;
+    git?: Partial<RepositoryGitSnapshot> | null;
+    inspectOnly?: boolean;
+}
+export type RepositoryCoverageEntityKind = 'route' | 'design-system' | 'test' | 'doc' | 'language' | 'usecase' | 'infrastructure' | 'decoupling';
+export interface RepositoryCoverageEntity {
+    id: string;
+    kind: RepositoryCoverageEntityKind;
+    label: string;
+    sourceFile: string;
+    detail: string;
+    meta?: string | null;
+}
+export interface RepositoryCoverageSection {
+    id: RepositoryCoverageEntityKind;
+    label: string;
+    count: number;
+    items: RepositoryCoverageEntity[];
+}
+export interface RepositoryCoverageDiagnostic {
+    id: string;
+    severity: RepositoryInspectionSeverity;
+    message: string;
+}
+export interface RepositoryCoverageSnapshot {
+    id: string;
+    projectRoot: string;
+    projectLabel: string;
+    generatedAt: string;
+    source: 'runtime' | 'script';
+    routes: RepositoryCoverageSection;
+    designSystem: RepositoryCoverageSection;
+    tests: RepositoryCoverageSection;
+    docs: RepositoryCoverageSection;
+    languages: RepositoryCoverageSection;
+    usecases: RepositoryCoverageSection;
+    infrastructure: RepositoryCoverageSection;
+    decoupling: RepositoryCoverageSection;
+    diagnostics: RepositoryCoverageDiagnostic[];
+    totals: {
+        files: number;
+        sections: number;
+        entities: number;
+    };
+}

package/dist/domain/repository/model.js

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

package/dist/domain/runtime/checkpoint.d.ts

@@ -0,0 +1,37 @@
+import type { LaunchProfile, LaunchTarget } from "../launch/model.js";
+import type { JsonValue } from "../shared/json.js";
+export type RuntimeCheckpointKind = 'project-state' | 'workspace-state' | 'runtime-session' | 'launch-profile' | 'tool-session' | 'last-known-good' | 'crash-snapshot' | 'restore-point';
+export interface RuntimeCheckpointInput {
+    id?: string;
+    kind: RuntimeCheckpointKind;
+    label: string;
+    target?: LaunchTarget | null;
+    profile?: LaunchProfile | null;
+    data?: unknown;
+    tags?: string[];
+    source?: string | null;
+}
+export interface RuntimeCheckpoint {
+    schemaVersion: 'runtime-checkpoint.v1';
+    id: string;
+    kind: RuntimeCheckpointKind;
+    label: string;
+    target: LaunchTarget | null;
+    profile: LaunchProfile | null;
+    data: JsonValue;
+    tags: string[];
+    source: string | null;
+    sizeBytes: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface RuntimeCheckpointSnapshot {
+    generatedAt: string;
+    checkpoints: RuntimeCheckpoint[];
+    lastKnownGoodId: string | null;
+    restorePointIds: string[];
+    totals: Record<RuntimeCheckpointKind, number>;
+}
+export declare function createRuntimeCheckpoint(input: RuntimeCheckpointInput, timestamp?: string): RuntimeCheckpoint;
+export declare function updateRuntimeCheckpoint(checkpoint: RuntimeCheckpoint, data: unknown, timestamp?: string): RuntimeCheckpoint;
+export declare function createRuntimeCheckpointSnapshot(checkpoints: RuntimeCheckpoint[], lastKnownGoodId?: string | null, timestamp?: string): RuntimeCheckpointSnapshot;

package/dist/domain/runtime/checkpoint.js

@@ -0,0 +1,87 @@
+export function createRuntimeCheckpoint(input, timestamp = new Date().toISOString()) {
+    const data = sanitizeJson(input.data ?? null);
+    return {
+        schemaVersion: 'runtime-checkpoint.v1',
+        id: input.id ?? `checkpoint:${input.kind}:${timestamp}`,
+        kind: input.kind,
+        label: sanitizeText(input.label, 160),
+        target: input.target ?? null,
+        profile: input.profile ?? input.target?.profile ?? null,
+        data,
+        tags: (input.tags ?? []).map((tag) => sanitizeText(tag, 80)).slice(0, 20),
+        source: normalizeNullableText(input.source, 160),
+        sizeBytes: estimateJsonSize(data),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+}
+export function updateRuntimeCheckpoint(checkpoint, data, timestamp = new Date().toISOString()) {
+    const sanitizedData = sanitizeJson(data);
+    return {
+        ...checkpoint,
+        data: sanitizedData,
+        sizeBytes: estimateJsonSize(sanitizedData),
+        updatedAt: timestamp
+    };
+}
+export function createRuntimeCheckpointSnapshot(checkpoints, lastKnownGoodId = null, timestamp = new Date().toISOString()) {
+    const sortedCheckpoints = [...checkpoints].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    return {
+        generatedAt: timestamp,
+        checkpoints: sortedCheckpoints,
+        lastKnownGoodId,
+        restorePointIds: sortedCheckpoints
+            .filter((checkpoint) => checkpoint.kind === 'restore-point' || checkpoint.id === lastKnownGoodId)
+            .map((checkpoint) => checkpoint.id),
+        totals: createCheckpointTotals(sortedCheckpoints)
+    };
+}
+const checkpointKinds = [
+    'project-state',
+    'workspace-state',
+    'runtime-session',
+    'launch-profile',
+    'tool-session',
+    'last-known-good',
+    'crash-snapshot',
+    'restore-point'
+];
+function createCheckpointTotals(checkpoints) {
+    const totals = Object.fromEntries(checkpointKinds.map((kind) => [kind, 0]));
+    for (const checkpoint of checkpoints) {
+        totals[checkpoint.kind] += 1;
+    }
+    return totals;
+}
+function estimateJsonSize(value) {
+    return JSON.stringify(value).length;
+}
+function normalizeNullableText(value, maxLength) {
+    return typeof value === 'string' ? sanitizeText(value, maxLength) : null;
+}
+function sanitizeText(value, maxLength = 2000) {
+    return value.length <= maxLength ? value : `${value.slice(0, maxLength - 1)}...`;
+}
+function sanitizeJson(value, depth = 0) {
+    if (value === null || typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        return sanitizeText(value);
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : null;
+    }
+    if (Array.isArray(value)) {
+        return depth >= 4 ? `[Array(${value.length})]` : value.slice(0, 50).map((entry) => sanitizeJson(entry, depth + 1));
+    }
+    if (value && typeof value === 'object') {
+        if (depth >= 4) {
+            return '[Object]';
+        }
+        return Object.fromEntries(Object.entries(value)
+            .slice(0, 50)
+            .map(([key, entry]) => [sanitizeText(key, 120), sanitizeJson(entry, depth + 1)]));
+    }
+    return null;
+}

package/dist/domain/runtime/hydration.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimePlan } from "./plan.js";
+export type RuntimeHydrationStepKind = 'documents' | 'graphs' | 'layouts' | 'sessions' | 'tools' | 'stores';
+export type RuntimeHydrationStepStatus = 'pending' | 'running' | 'completed' | 'failed';
+export interface RuntimeHydrationStep {
+    id: string;
+    kind: RuntimeHydrationStepKind;
+    label: string;
+    status: RuntimeHydrationStepStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    message: string | null;
+}
+export interface RuntimeHydrationSnapshot {
+    planId: string;
+    status: 'idle' | 'running' | 'completed' | 'failed' | 'partial';
+    activeStepId: string | null;
+    progress: number;
+    steps: RuntimeHydrationStep[];
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    error: string | null;
+}
+export declare function createRuntimeHydrationSnapshot(plan: RuntimePlan, timestamp?: string): RuntimeHydrationSnapshot;
+export declare function completeRuntimeHydrationStep(snapshot: RuntimeHydrationSnapshot, stepId: string, timestamp?: string, message?: string | null): RuntimeHydrationSnapshot;
+export declare function failRuntimeHydrationStep(snapshot: RuntimeHydrationSnapshot, stepId: string, error: string, timestamp?: string): RuntimeHydrationSnapshot;

package/dist/domain/runtime/hydration.js

@@ -0,0 +1,92 @@
+const DEFAULT_HYDRATION_STEPS = [
+    { kind: 'documents', label: 'Hydrate documents' },
+    { kind: 'graphs', label: 'Hydrate graphs' },
+    { kind: 'layouts', label: 'Hydrate layouts' },
+    { kind: 'sessions', label: 'Hydrate sessions' },
+    { kind: 'tools', label: 'Hydrate tools' },
+    { kind: 'stores', label: 'Hydrate stores' }
+];
+export function createRuntimeHydrationSnapshot(plan, timestamp = new Date().toISOString()) {
+    const steps = DEFAULT_HYDRATION_STEPS.map((step) => ({
+        id: `hydrate:${step.kind}`,
+        kind: step.kind,
+        label: step.label,
+        status: 'pending',
+        startedAt: null,
+        completedAt: null,
+        message: null
+    }));
+    const firstStep = steps[0] ?? null;
+    return {
+        planId: plan.id,
+        status: 'running',
+        activeStepId: firstStep?.id ?? null,
+        progress: 0,
+        steps: firstStep
+            ? steps.map((step) => step.id === firstStep.id ? { ...step, status: 'running', startedAt: timestamp } : step)
+            : steps,
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        error: null
+    };
+}
+export function completeRuntimeHydrationStep(snapshot, stepId, timestamp = new Date().toISOString(), message = null) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'completed',
+            completedAt: timestamp,
+            message
+        }
+        : step);
+    const nextPendingStep = steps.find((step) => step.status === 'pending') ?? null;
+    const nextSteps = nextPendingStep
+        ? steps.map((step) => step.id === nextPendingStep.id
+            ? {
+                ...step,
+                status: 'running',
+                startedAt: timestamp
+            }
+            : step)
+        : steps;
+    const progress = calculateHydrationProgress(nextSteps);
+    const completed = progress >= 100;
+    return {
+        ...snapshot,
+        status: completed ? 'completed' : 'running',
+        activeStepId: completed ? null : nextPendingStep?.id ?? null,
+        progress,
+        steps: nextSteps,
+        updatedAt: timestamp,
+        completedAt: completed ? timestamp : null,
+        error: null
+    };
+}
+export function failRuntimeHydrationStep(snapshot, stepId, error, timestamp = new Date().toISOString()) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'failed',
+            completedAt: timestamp,
+            message: error
+        }
+        : step);
+    return {
+        ...snapshot,
+        status: 'failed',
+        activeStepId: null,
+        progress: calculateHydrationProgress(steps),
+        steps,
+        updatedAt: timestamp,
+        completedAt: timestamp,
+        error
+    };
+}
+function calculateHydrationProgress(steps) {
+    if (steps.length === 0) {
+        return 100;
+    }
+    const resolvedSteps = steps.filter((step) => step.status === 'completed').length;
+    return Math.round((resolvedSteps / steps.length) * 100);
+}

package/dist/domain/runtime/initialization.d.ts

@@ -0,0 +1,25 @@
+import type { RuntimePlan } from "./plan.js";
+export type RuntimeInitializationStepStatus = 'pending' | 'running' | 'completed' | 'skipped' | 'failed';
+export interface RuntimeInitializationStep {
+    id: string;
+    planStepId: string;
+    label: string;
+    status: RuntimeInitializationStepStatus;
+    startedAt: string | null;
+    completedAt: string | null;
+    message: string | null;
+}
+export interface RuntimeInitializationSnapshot {
+    planId: string;
+    status: 'idle' | 'running' | 'completed' | 'failed';
+    activeStepId: string | null;
+    progress: number;
+    steps: RuntimeInitializationStep[];
+    startedAt: string;
+    updatedAt: string;
+    completedAt: string | null;
+    error: string | null;
+}
+export declare function createRuntimeInitializationSnapshot(plan: RuntimePlan, timestamp?: string): RuntimeInitializationSnapshot;
+export declare function completeRuntimeInitializationStep(snapshot: RuntimeInitializationSnapshot, stepId: string, timestamp?: string, message?: string | null): RuntimeInitializationSnapshot;
+export declare function failRuntimeInitializationStep(snapshot: RuntimeInitializationSnapshot, stepId: string, error: string, timestamp?: string): RuntimeInitializationSnapshot;

package/dist/domain/runtime/initialization.js

@@ -0,0 +1,87 @@
+export function createRuntimeInitializationSnapshot(plan, timestamp = new Date().toISOString()) {
+    const steps = plan.steps.map((step) => createInitializationStep(step, timestamp));
+    const firstPendingStep = steps.find((step) => step.status === 'pending') ?? null;
+    return {
+        planId: plan.id,
+        status: plan.canExecute ? 'running' : 'failed',
+        activeStepId: firstPendingStep?.id ?? null,
+        progress: calculateInitializationProgress(steps),
+        steps: firstPendingStep
+            ? steps.map((step) => step.id === firstPendingStep.id ? { ...step, status: 'running', startedAt: timestamp } : step)
+            : steps,
+        startedAt: timestamp,
+        updatedAt: timestamp,
+        completedAt: null,
+        error: plan.canExecute ? null : 'Runtime plan is blocked.'
+    };
+}
+export function completeRuntimeInitializationStep(snapshot, stepId, timestamp = new Date().toISOString(), message = null) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'completed',
+            completedAt: timestamp,
+            message
+        }
+        : step);
+    const nextPendingStep = steps.find((step) => step.status === 'pending') ?? null;
+    const nextSteps = nextPendingStep
+        ? steps.map((step) => step.id === nextPendingStep.id
+            ? {
+                ...step,
+                status: 'running',
+                startedAt: timestamp
+            }
+            : step)
+        : steps;
+    const progress = calculateInitializationProgress(nextSteps);
+    const completed = progress >= 100;
+    return {
+        ...snapshot,
+        status: completed ? 'completed' : 'running',
+        activeStepId: completed ? null : nextPendingStep?.id ?? null,
+        progress,
+        steps: nextSteps,
+        updatedAt: timestamp,
+        completedAt: completed ? timestamp : null,
+        error: null
+    };
+}
+export function failRuntimeInitializationStep(snapshot, stepId, error, timestamp = new Date().toISOString()) {
+    const steps = snapshot.steps.map((step) => step.id === stepId
+        ? {
+            ...step,
+            status: 'failed',
+            completedAt: timestamp,
+            message: error
+        }
+        : step);
+    return {
+        ...snapshot,
+        status: 'failed',
+        activeStepId: null,
+        progress: calculateInitializationProgress(steps),
+        steps,
+        updatedAt: timestamp,
+        completedAt: timestamp,
+        error
+    };
+}
+function createInitializationStep(step, timestamp) {
+    return {
+        id: `init:${step.id}`,
+        planStepId: step.id,
+        label: step.label,
+        status: step.status === 'skipped' ? 'skipped' : step.status === 'blocked' ? 'failed' : 'pending',
+        startedAt: null,
+        completedAt: step.status === 'skipped' || step.status === 'blocked' ? timestamp : null,
+        message: step.reason
+    };
+}
+function calculateInitializationProgress(steps) {
+    if (steps.length === 0) {
+        return 100;
+    }
+    const resolvedSteps = steps.filter((step) => step.status === 'completed' || step.status === 'skipped').length;
+    return Math.round((resolvedSteps / steps.length) * 100);
+}

package/dist/domain/runtime/lifecycle.d.ts

@@ -0,0 +1,51 @@
+import type { LaunchPhase } from "../launch/model.js";
+export type RuntimeLifecycleState = LaunchPhase;
+export type RuntimeLifecycleMacroPhase = 'boot' | 'launch' | 'planning' | 'initialization' | 'hydration' | 'running' | 'suspension' | 'teardown' | 'recovery';
+export type RuntimeLifecycleHealth = 'idle' | 'progressing' | 'healthy' | 'recovering' | 'safe-mode' | 'blocked';
+export interface RuntimeLifecycleTransition {
+    id: string;
+    from: RuntimeLifecycleState | null;
+    to: RuntimeLifecycleState;
+    accepted: boolean;
+    timestamp: string;
+    message: string;
+}
+export interface RuntimeLifecycleTransitionError {
+    id: string;
+    from: RuntimeLifecycleState | null;
+    to: RuntimeLifecycleState;
+    timestamp: string;
+    message: string;
+}
+export interface RuntimeLifecycleSnapshot {
+    state: RuntimeLifecycleState;
+    previousState: RuntimeLifecycleState | null;
+    transitions: RuntimeLifecycleTransition[];
+    errors: RuntimeLifecycleTransitionError[];
+    updatedAt: string;
+}
+export interface RuntimeLifecycleSummary {
+    state: RuntimeLifecycleState;
+    previousState: RuntimeLifecycleState | null;
+    macroPhase: RuntimeLifecycleMacroPhase;
+    health: RuntimeLifecycleHealth;
+    acceptedTransitions: number;
+    rejectedTransitions: number;
+    latestTransitionAt: string | null;
+    updatedAt: string;
+}
+export interface RuntimeLifecycleTransitionInput {
+    id: string;
+    timestamp: string;
+    message?: string;
+    maxTransitions?: number;
+    maxErrors?: number;
+}
+export declare const RUNTIME_LIFECYCLE_ALLOWED_TRANSITIONS: Record<RuntimeLifecycleState, readonly RuntimeLifecycleState[]>;
+export declare const RUNTIME_LIFECYCLE_MACRO_PHASES: Record<RuntimeLifecycleState, RuntimeLifecycleMacroPhase>;
+export declare function createRuntimeLifecycleSnapshot(state?: RuntimeLifecycleState, timestamp?: string): RuntimeLifecycleSnapshot;
+export declare function canTransitionRuntimeLifecycle(from: RuntimeLifecycleState | null, to: RuntimeLifecycleState): boolean;
+export declare function transitionRuntimeLifecycleSnapshot(snapshot: RuntimeLifecycleSnapshot, to: RuntimeLifecycleState, input: RuntimeLifecycleTransitionInput): RuntimeLifecycleSnapshot;
+export declare function resolveRuntimeLifecycleMacroPhase(state: RuntimeLifecycleState): RuntimeLifecycleMacroPhase;
+export declare function resolveRuntimeLifecycleHealth(snapshot: RuntimeLifecycleSnapshot): RuntimeLifecycleHealth;
+export declare function createRuntimeLifecycleSummary(snapshot: RuntimeLifecycleSnapshot): RuntimeLifecycleSummary;