@shapeshift-labs/frontier-lang-compiler 0.2.66 → 0.2.68

package/dist/universal-conversion-plan.js

@@ -9,6 +9,10 @@ import {
   normalizeProjectionMatrixTargets
 } from './coverage-matrix-profiles.js';
 import { createUniversalCapabilityMatrix } from './universal-capability-matrix.js';
+import {
+  createUniversalRuntimeCapabilityMatrix,
+  runtimeRouteForConversion
+} from './universal-runtime-capabilities.js';
 import {
   conversionMergeRefs,
   importsForConversionLanguage
@@ -17,6 +21,7 @@ import {
   conversionMergeScore,
   conversionScoreComponents
 } from './universal-conversion-plan-scoring.js';
+import { conversionPlanSummary } from './universal-conversion-plan-summary.js';
 
 export function createUniversalConversionPlan(input = {}, context = {}) {
   const generatedAt = input.generatedAt ?? Date.now();
@@ -25,12 +30,21 @@ export function createUniversalConversionPlan(input = {}, context = {}) {
     ? input.universalCapabilityMatrix
     : createUniversalCapabilityMatrix({ ...input, generatedAt }, context);
   const targets = conversionTargets(input, matrix, context);
+  const runtimeMatrix = input.universalRuntimeCapabilityMatrix?.kind === 'frontier.lang.universalRuntimeCapabilityMatrix'
+    ? input.universalRuntimeCapabilityMatrix
+    : createUniversalRuntimeCapabilityMatrix({
+      ...input,
+      generatedAt,
+      sourceLanguages: matrix.languages,
+      targets
+    }, context);
   const evidence = input.evidence ?? [];
   const routes = (matrix.languages ?? []).flatMap((language) => targets.map((target) => conversionRoute(language, target, {
     evidence,
     generatedAt,
     imports: input.imports ?? [],
-    matrix
+    matrix,
+    runtimeMatrix
   }, id)));
   return {
     kind: 'frontier.lang.universalConversionPlan',
@@ -41,6 +55,7 @@ export function createUniversalConversionPlan(input = {}, context = {}) {
     summary: conversionPlanSummary(routes),
     matrices: {
       universalCapability: matrix,
+      runtimeCapabilities: runtimeMatrix,
       projectionReadiness: matrix.matrices?.projectionReadiness,
       projectionTargets: matrix.matrices?.projectionTargets
     },
@@ -90,6 +105,8 @@ function conversionRoute(language, target, input, planId) {
   const sourceTarget = nativeLanguageCompileTarget(language.language, language.aliases) ?? normalizeNativeLanguageId(language.language);
   const targetCell = (language.projection?.targets ?? []).find((entry) => entry.target === target);
   const readinessCell = projectionReadinessCell(input.matrix, language, target);
+  const runtimeRoute = runtimeRouteForConversion(input.runtimeMatrix, language, target);
+  const runtime = conversionRuntime(runtimeRoute);
   const mode = conversionMode(language, target, sourceTarget, targetCell);
   const blockers = conversionBlockers(language, targetCell, mode);
   const review = conversionReviewReasons(language, targetCell, mode);
@@ -115,6 +132,8 @@ function conversionRoute(language, target, input, planId) {
     adapterKind: targetCell?.adapterKind,
     sourceProjection: language.projection?.sourceProjection,
     projectionReadiness: readinessCell,
+    runtime,
+    runtimeAdapterRequirements: runtime.adapterRequirements,
     evidence: conversionEvidence(language, targetCell),
     missingEvidence: conversionMissingEvidence(language, targetCell, mode),
     blockers,
@@ -172,6 +191,32 @@ function conversionReviewReasons(language, targetCell, mode) {
   ]);
 }
 
+function conversionRuntime(runtimeRoute) {
+  if (!runtimeRoute) {
+    return {
+      requiredCapabilities: [],
+      satisfiedCapabilities: [],
+      adapterRequirements: [],
+      missingCapabilities: [],
+      readiness: 'ready',
+      blockers: [],
+      review: []
+    };
+  }
+  return {
+    routeId: runtimeRoute.id,
+    source: runtimeRoute.source,
+    target: runtimeRoute.target,
+    requiredCapabilities: runtimeRoute.requiredCapabilities,
+    satisfiedCapabilities: runtimeRoute.satisfiedCapabilities,
+    adapterRequirements: runtimeRoute.adapterRequirements,
+    missingCapabilities: runtimeRoute.missingCapabilities,
+    readiness: runtimeRoute.readiness,
+    blockers: runtimeRoute.blockers,
+    review: runtimeRoute.review
+  };
+}
+
 function projectionReadinessCell(matrix, language, target) {
   const ids = uniqueStrings([language.language, ...(language.aliases ?? [])].map(normalizeNativeLanguageId));
   return (matrix.matrices?.projectionReadiness?.languages ?? [])
@@ -238,42 +283,3 @@ function conversionTasks(language, target, mode, blockers, review) {
     ...(blockers.length || review.length ? [`collect proof, replay, or oracle evidence for ${language.language} to ${target}`] : [])
   ]);
 }
-
-function conversionPlanSummary(routes) {
-  const summary = {
-    routes: routes.length,
-    byMode: {},
-    byReadiness: {},
-    byAdmissionAction: {},
-    readyRoutes: 0,
-    reviewRoutes: 0,
-    blockedRoutes: 0,
-    preserveSourceRoutes: 0,
-    targetAdapterRoutes: 0,
-    stubOnlyRoutes: 0,
-    semanticIndexOnlyRoutes: 0,
-    missingEvidence: 0,
-    blockers: 0,
-    reviewReasons: 0,
-    autoMergeClaims: 0,
-    semanticEquivalenceClaims: 0
-  };
-  for (const route of routes) {
-    summary.byMode[route.mode] = (summary.byMode[route.mode] ?? 0) + 1;
-    summary.byReadiness[route.readiness] = (summary.byReadiness[route.readiness] ?? 0) + 1;
-    summary.byAdmissionAction[route.admissionAction] = (summary.byAdmissionAction[route.admissionAction] ?? 0) + 1;
-    if (route.readiness === 'ready') summary.readyRoutes += 1;
-    if (route.readiness === 'needs-review' || route.readiness === 'ready-with-losses') summary.reviewRoutes += 1;
-    if (route.readiness === 'blocked') summary.blockedRoutes += 1;
-    if (route.mode === 'preserve-source') summary.preserveSourceRoutes += 1;
-    if (route.mode === 'target-adapter') summary.targetAdapterRoutes += 1;
-    if (route.mode === 'stub-only') summary.stubOnlyRoutes += 1;
-    if (route.mode === 'semantic-index-only') summary.semanticIndexOnlyRoutes += 1;
-    summary.missingEvidence += route.missingEvidence.length;
-    summary.blockers += route.blockers.length;
-    summary.reviewReasons += route.review.length;
-    if (route.autoMergeClaim) summary.autoMergeClaims += 1;
-    if (route.semanticEquivalenceClaim) summary.semanticEquivalenceClaims += 1;
-  }
-  return summary;
-}

package/dist/universal-runtime-capabilities.js

@@ -0,0 +1,92 @@
+import {
+  normalizeNativeLanguageId,
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  normalizeProjectionMatrixTargets
+} from './coverage-matrix-profiles.js';
+import {
+  UniversalRuntimeCapabilityKinds,
+  UniversalRuntimeHostProfiles
+} from './universal-runtime-profiles.js';
+import {
+  normalizeRuntimeCapabilityKind,
+  normalizeRuntimeHostProfiles,
+  normalizeRuntimeId,
+  normalizeRuntimeRequirements,
+  runtimeSourceHosts,
+  runtimeTargetHosts
+} from './universal-runtime-host-selectors.js';
+import {
+  runtimeCapabilityMatrixSummary,
+  runtimeRoute
+} from './universal-runtime-route-records.js';
+
+export {
+  UniversalRuntimeCapabilityKinds,
+  UniversalRuntimeHostProfiles
+} from './universal-runtime-profiles.js';
+
+export function createUniversalRuntimeCapabilityMatrix(input = {}, context = {}) {
+  const generatedAt = input.generatedAt ?? Date.now();
+  const hostProfiles = normalizeRuntimeHostProfiles(input.hostProfiles ?? input.runtimeHosts ?? UniversalRuntimeHostProfiles);
+  const sourceHosts = runtimeSourceHosts(input, hostProfiles);
+  const targetHosts = runtimeTargetHosts(input, hostProfiles, context);
+  const requirements = normalizeRuntimeRequirements(input, hostProfiles);
+  const routes = sourceHosts.flatMap((sourceHost) => targetHosts.map((targetHost) => runtimeRoute(sourceHost, targetHost, {
+    generatedAt,
+    requirements
+  })));
+  return {
+    kind: 'frontier.lang.universalRuntimeCapabilityMatrix',
+    version: 1,
+    generatedAt,
+    hostProfiles,
+    routes,
+    summary: runtimeCapabilityMatrixSummary(routes),
+    metadata: {
+      capabilityKinds: [...UniversalRuntimeCapabilityKinds],
+      sourceHosts: sourceHosts.map((host) => host.id),
+      targetHosts: targetHosts.map((host) => host.id),
+      note: 'Runtime capability coverage is declarative host evidence for adapter planning. It does not import, polyfill, or execute host APIs.'
+    }
+  };
+}
+
+export function queryUniversalRuntimeCapabilityMatrix(matrixOrInput = {}, query = {}, context = {}) {
+  const matrix = matrixOrInput?.kind === 'frontier.lang.universalRuntimeCapabilityMatrix'
+    ? matrixOrInput
+    : createUniversalRuntimeCapabilityMatrix(matrixOrInput, context);
+  const sourceLanguage = normalizeNativeLanguageId(query.sourceLanguage ?? query.language);
+  const target = normalizeProjectionMatrixTargets(query.target ? [query.target] : [])[0];
+  const sourceRuntime = normalizeRuntimeId(query.sourceRuntime ?? query.runtime);
+  const targetRuntime = normalizeRuntimeId(query.targetRuntime);
+  const capability = normalizeRuntimeCapabilityKind(query.capability);
+  const routes = (matrix.routes ?? []).filter((route) => {
+    if (sourceLanguage && !route.source.languageIds.includes(sourceLanguage)) return false;
+    if (target && route.target.target !== target) return false;
+    if (sourceRuntime && route.source.runtime !== sourceRuntime && route.source.id !== sourceRuntime) return false;
+    if (targetRuntime && route.target.runtime !== targetRuntime && route.target.id !== targetRuntime) return false;
+    if (capability && !route.requiredCapabilities.includes(capability)) return false;
+    if (query.requiresAdapter === true && route.adapterRequirements.length === 0) return false;
+    if (query.requiresAdapter === false && route.adapterRequirements.length > 0) return false;
+    return true;
+  });
+  return {
+    kind: 'frontier.lang.universalRuntimeCapabilityMatrixQuery',
+    version: 1,
+    found: routes.length > 0,
+    routes,
+    bestRoute: routes[0],
+    reasons: routes.length ? [] : [`No runtime capability route matched source=${query.sourceLanguage ?? query.language ?? '*'} target=${query.target ?? '*'}.`]
+  };
+}
+
+export function runtimeRouteForConversion(runtimeMatrix, language, target) {
+  const languageIds = uniqueStrings([language?.language, ...(language?.aliases ?? [])].map(normalizeNativeLanguageId));
+  const normalizedTarget = normalizeProjectionMatrixTargets([target])[0] ?? String(target ?? '');
+  return (runtimeMatrix?.routes ?? []).find((route) => {
+    if (normalizedTarget && route.target.target !== normalizedTarget) return false;
+    return route.source.languageIds.some((id) => languageIds.includes(id));
+  });
+}

package/dist/universal-runtime-host-selectors.js

@@ -0,0 +1,192 @@
+import {
+  normalizeNativeLanguageId,
+  uniqueStrings
+} from './native-import-utils.js';
+import {
+  nativeLanguageCompileTarget,
+  normalizeProjectionMatrixTargets
+} from './coverage-matrix-profiles.js';
+
+export function normalizeRuntimeHostProfiles(profiles) {
+  return (profiles ?? []).map((profile) => {
+    const language = normalizeNativeLanguageId(profile.language);
+    const runtime = normalizeRuntimeId(profile.runtime ?? profile.host ?? 'host');
+    const id = profile.id ?? `${language}:${runtime}`;
+    const aliases = uniqueStrings((profile.aliases ?? []).map(normalizeNativeLanguageId));
+    const capabilities = Object.fromEntries(Object.entries(profile.capabilities ?? {})
+      .map(([kind, value]) => {
+        const normalizedKind = normalizeRuntimeCapabilityKind(value?.kind ?? kind);
+        return [normalizedKind, {
+          kind: normalizedKind,
+          support: normalizeCapabilitySupport(value?.support),
+          binding: String(value?.binding ?? `${id}.${normalizedKind}`),
+          notes: uniqueStrings(value?.notes ?? [])
+        }];
+      }));
+    return {
+      id,
+      language,
+      aliases,
+      languageIds: uniqueStrings([language, ...aliases]),
+      runtime,
+      host: String(profile.host ?? runtime),
+      target: normalizeProjectionMatrixTargets([profile.target ?? nativeLanguageCompileTarget(language, aliases) ?? language])[0] ?? language,
+      capabilities,
+      notes: uniqueStrings(profile.notes ?? [])
+    };
+  });
+}
+
+export function runtimeSourceHosts(input, hostProfiles) {
+  const explicit = normalizeHostSelectors(input.sourceHosts ?? input.sourceRuntimeHosts, hostProfiles);
+  if (explicit.length) return explicit;
+  const languages = uniqueStrings([
+    ...(input.sourceLanguages ?? input.languages ?? []).map((entry) => entry?.language ?? entry),
+    ...(input.imports ?? []).map((entry) => entry?.language ?? entry?.nativeAst?.language ?? entry?.nativeSource?.language),
+    ...runtimeRequirementRecords(input).map((entry) => entry.sourceLanguage ?? entry.language)
+  ].map(normalizeNativeLanguageId));
+  return (languages.length ? languages : ['javascript'])
+    .map((language) => defaultHostForLanguage(language, hostProfiles, input.sourceRuntimes?.[language] ?? input.sourceRuntime))
+    .filter(Boolean);
+}
+
+export function runtimeTargetHosts(input, hostProfiles, context) {
+  const explicit = normalizeHostSelectors(input.targetHosts ?? input.targetRuntimeHosts, hostProfiles);
+  if (explicit.length) return explicit;
+  const targets = normalizeProjectionMatrixTargets(input.targets ?? context.compileTargets ?? []);
+  const targetList = targets.length ? targets : ['javascript'];
+  return targetList.map((target) => defaultHostForTarget(target, hostProfiles, input.targetRuntimes?.[target] ?? input.targetRuntime));
+}
+
+function normalizeHostSelectors(value, hostProfiles) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value.map((entry) => resolveHostSelector(entry, hostProfiles)).filter(Boolean);
+  if (typeof value === 'object') return Object.values(value).map((entry) => resolveHostSelector(entry, hostProfiles)).filter(Boolean);
+  return [resolveHostSelector(value, hostProfiles)].filter(Boolean);
+}
+
+function resolveHostSelector(value, hostProfiles) {
+  if (!value) return undefined;
+  if (typeof value === 'object') return normalizeRuntimeHostProfiles([value])[0];
+  const normalized = normalizeRuntimeId(value);
+  return hostProfiles.find((profile) => profile.id === normalized)
+    ?? hostProfiles.find((profile) => `${profile.language}:${profile.runtime}` === normalized)
+    ?? hostProfiles.find((profile) => profile.language === normalized)
+    ?? genericHostProfile(normalized, normalized);
+}
+
+function defaultHostForLanguage(language, hostProfiles, runtime) {
+  const normalizedLanguage = normalizeNativeLanguageId(language);
+  const normalizedRuntime = normalizeRuntimeId(runtime);
+  return hostProfiles.find((profile) => profile.language === normalizedLanguage && (!normalizedRuntime || profile.runtime === normalizedRuntime || profile.id === normalizedRuntime))
+    ?? hostProfiles.find((profile) => profile.languageIds.includes(normalizedLanguage))
+    ?? genericHostProfile(`${normalizedLanguage}:host`, normalizedLanguage);
+}
+
+function defaultHostForTarget(target, hostProfiles, runtime) {
+  const normalizedTarget = normalizeProjectionMatrixTargets([target])[0] ?? normalizeNativeLanguageId(target);
+  const normalizedRuntime = normalizeRuntimeId(runtime);
+  return hostProfiles.find((profile) => profile.target === normalizedTarget && (!normalizedRuntime || profile.runtime === normalizedRuntime || profile.id === normalizedRuntime))
+    ?? hostProfiles.find((profile) => profile.language === normalizedTarget)
+    ?? genericHostProfile(`${normalizedTarget}:host`, normalizedTarget);
+}
+
+function genericHostProfile(id, language) {
+  const normalizedLanguage = normalizeNativeLanguageId(language);
+  const normalizedId = String(id || `${normalizedLanguage}:host`);
+  return {
+    id: normalizedId,
+    language: normalizedLanguage,
+    aliases: [],
+    languageIds: [normalizedLanguage],
+    runtime: normalizedId.includes(':') ? normalizedId.split(':').at(-1) : 'host',
+    host: 'host',
+    target: normalizedLanguage,
+    capabilities: {},
+    notes: ['No built-in runtime host profile was available; callers may provide hostProfiles for stronger adapter planning.']
+  };
+}
+
+export function normalizeRuntimeRequirements(input, hostProfiles) {
+  const records = [
+    ...runtimeRequirementRecords(input),
+    ...runtimeRequirementRecordsFromImports(input.imports)
+  ];
+  return records.flatMap((record) => normalizeRuntimeRequirementRecord(record, hostProfiles));
+}
+
+function runtimeRequirementRecords(input) {
+  if (!input) return [];
+  const value = input.runtimeRequirements ?? input.requiredRuntimeCapabilities ?? input.effects ?? [];
+  if (Array.isArray(value)) return value;
+  if (typeof value === 'object') {
+    return Object.entries(value).map(([key, capabilities]) => ({
+      sourceLanguage: key,
+      capabilities
+    }));
+  }
+  return [value];
+}
+
+function runtimeRequirementRecordsFromImports(imports) {
+  return (imports ?? []).flatMap((imported) => {
+    const value = imported?.runtimeRequirements
+      ?? imported?.metadata?.runtimeRequirements
+      ?? imported?.metadata?.runtimeCapabilities
+      ?? imported?.metadata?.effects;
+    const records = Array.isArray(value) ? value : value ? [value] : [];
+    return records.map((record) => typeof record === 'string'
+      ? { sourceLanguage: imported?.language ?? imported?.nativeAst?.language, capabilities: [record] }
+      : { sourceLanguage: imported?.language ?? imported?.nativeAst?.language, ...record });
+  });
+}
+
+function normalizeRuntimeRequirementRecord(record, hostProfiles) {
+  if (!record) return [];
+  if (typeof record === 'string') return [{ capability: normalizeRuntimeCapabilityKind(record) }].filter((entry) => entry.capability);
+  const capabilities = uniqueStrings([
+    ...(Array.isArray(record.capabilities) ? record.capabilities : []),
+    ...(Array.isArray(record.requiredCapabilities) ? record.requiredCapabilities : []),
+    record.capability,
+    record.kind
+  ].map(normalizeRuntimeCapabilityKind).filter(Boolean));
+  const sourceHost = resolveHostSelector(record.sourceHost ?? record.sourceRuntimeHost, hostProfiles);
+  const targetHost = resolveHostSelector(record.targetHost ?? record.targetRuntimeHost, hostProfiles);
+  return capabilities.map((capability) => ({
+    capability,
+    sourceLanguage: normalizeNativeLanguageId(record.sourceLanguage ?? record.language ?? sourceHost?.language),
+    sourceRuntime: normalizeRuntimeId(record.sourceRuntime ?? record.runtime ?? sourceHost?.runtime),
+    sourceHostId: sourceHost?.id,
+    target: normalizeProjectionMatrixTargets(record.target ? [record.target] : [])[0],
+    targetRuntime: normalizeRuntimeId(record.targetRuntime ?? targetHost?.runtime),
+    targetHostId: targetHost?.id,
+    reason: record.reason,
+    evidenceIds: uniqueStrings(record.evidenceIds ?? [])
+  }));
+}
+
+export function normalizeRuntimeCapabilityKind(value) {
+  if (!value) return '';
+  const text = String(value).trim().toLowerCase();
+  if (text === 'http' || text === 'network' || text === 'networking') return 'fetch';
+  if (text === 'timer' || text === 'clock' || text === 'scheduler') return 'timers';
+  if (text === 'localstorage' || text === 'local-storage' || text === 'persistence') return 'storage';
+  if (text === 'file' || text === 'files' || text === 'fs') return 'filesystem';
+  if (text === 'threads' || text === 'workers' || text === 'worker') return 'threading';
+  if (text === 'browser-dom' || text === 'document') return 'dom';
+  if (text === 'promise' || text === 'promises' || text === 'await') return 'async';
+  if (text === 'native-ffi' || text === 'abi') return 'ffi';
+  return text;
+}
+
+export function normalizeRuntimeId(value) {
+  if (!value) return '';
+  return String(value).trim().toLowerCase();
+}
+
+function normalizeCapabilitySupport(value) {
+  const support = String(value ?? 'native').trim().toLowerCase();
+  if (support === 'native' || support === 'adapter' || support === 'unavailable') return support;
+  if (support === 'unsupported' || support === 'missing' || support === 'none') return 'unavailable';
+  return support;
+}

package/dist/universal-runtime-profiles.js

@@ -0,0 +1,109 @@
+export const UniversalRuntimeCapabilityKinds = Object.freeze([
+  'fetch',
+  'timers',
+  'storage',
+  'filesystem',
+  'threading',
+  'dom',
+  'async',
+  'ffi'
+]);
+
+export const UniversalRuntimeHostProfiles = Object.freeze([
+  runtimeHostProfile('javascript:web', 'javascript', 'web', 'browser', 'javascript', {
+    fetch: runtimeCapability('fetch', 'native', 'web.fetch'),
+    timers: runtimeCapability('timers', 'native', 'web.timers'),
+    storage: runtimeCapability('storage', 'native', 'web.storage'),
+    filesystem: runtimeCapability('filesystem', 'unavailable', 'web.no-filesystem'),
+    threading: runtimeCapability('threading', 'adapter', 'web.workers'),
+    dom: runtimeCapability('dom', 'native', 'web.dom'),
+    async: runtimeCapability('async', 'native', 'web.promise-event-loop'),
+    ffi: runtimeCapability('ffi', 'unavailable', 'web.no-native-ffi')
+  }, ['js', 'jsx']),
+  runtimeHostProfile('typescript:web', 'typescript', 'web', 'browser', 'typescript', {
+    fetch: runtimeCapability('fetch', 'native', 'web.fetch'),
+    timers: runtimeCapability('timers', 'native', 'web.timers'),
+    storage: runtimeCapability('storage', 'native', 'web.storage'),
+    filesystem: runtimeCapability('filesystem', 'unavailable', 'web.no-filesystem'),
+    threading: runtimeCapability('threading', 'adapter', 'web.workers'),
+    dom: runtimeCapability('dom', 'native', 'web.dom'),
+    async: runtimeCapability('async', 'native', 'web.promise-event-loop'),
+    ffi: runtimeCapability('ffi', 'unavailable', 'web.no-native-ffi')
+  }, ['ts', 'tsx']),
+  runtimeHostProfile('javascript:node', 'javascript', 'node', 'node', 'javascript', {
+    fetch: runtimeCapability('fetch', 'native', 'node.fetch'),
+    timers: runtimeCapability('timers', 'native', 'node.timers'),
+    storage: runtimeCapability('storage', 'adapter', 'node.storage-adapter'),
+    filesystem: runtimeCapability('filesystem', 'native', 'node.fs'),
+    threading: runtimeCapability('threading', 'adapter', 'node.worker-threads'),
+    dom: runtimeCapability('dom', 'unavailable', 'node.no-dom'),
+    async: runtimeCapability('async', 'native', 'node.promise-event-loop'),
+    ffi: runtimeCapability('ffi', 'adapter', 'node.native-addon')
+  }, ['nodejs']),
+  runtimeHostProfile('rust:cli', 'rust', 'cli', 'native-cli', 'rust', {
+    fetch: runtimeCapability('fetch', 'adapter', 'rust.http-client'),
+    timers: runtimeCapability('timers', 'native', 'rust.timer'),
+    storage: runtimeCapability('storage', 'adapter', 'rust.filesystem-storage'),
+    filesystem: runtimeCapability('filesystem', 'native', 'rust.std-fs'),
+    threading: runtimeCapability('threading', 'native', 'rust.std-thread'),
+    dom: runtimeCapability('dom', 'unavailable', 'rust.no-dom'),
+    async: runtimeCapability('async', 'adapter', 'rust.async-runtime'),
+    ffi: runtimeCapability('ffi', 'native', 'rust.ffi')
+  }, ['rs']),
+  runtimeHostProfile('python:cli', 'python', 'cli', 'native-cli', 'python', {
+    fetch: runtimeCapability('fetch', 'adapter', 'python.http-client'),
+    timers: runtimeCapability('timers', 'native', 'python.timers'),
+    storage: runtimeCapability('storage', 'adapter', 'python.persistence'),
+    filesystem: runtimeCapability('filesystem', 'native', 'python.filesystem'),
+    threading: runtimeCapability('threading', 'native', 'python.threading'),
+    dom: runtimeCapability('dom', 'unavailable', 'python.no-dom'),
+    async: runtimeCapability('async', 'native', 'python.asyncio'),
+    ffi: runtimeCapability('ffi', 'native', 'python.ctypes')
+  }, ['py']),
+  runtimeHostProfile('c:cli', 'c', 'cli', 'native-cli', 'c', {
+    fetch: runtimeCapability('fetch', 'adapter', 'c.http-client'),
+    timers: runtimeCapability('timers', 'native', 'c.timers'),
+    storage: runtimeCapability('storage', 'adapter', 'c.persistence'),
+    filesystem: runtimeCapability('filesystem', 'native', 'c.filesystem'),
+    threading: runtimeCapability('threading', 'native', 'c.threads'),
+    dom: runtimeCapability('dom', 'unavailable', 'c.no-dom'),
+    async: runtimeCapability('async', 'adapter', 'c.event-loop'),
+    ffi: runtimeCapability('ffi', 'native', 'c.abi')
+  }, ['h']),
+  runtimeHostProfile('cpp:cli', 'cpp', 'cli', 'native-cli', 'cpp', {
+    fetch: runtimeCapability('fetch', 'adapter', 'cpp.http-client'),
+    timers: runtimeCapability('timers', 'native', 'cpp.timers'),
+    storage: runtimeCapability('storage', 'adapter', 'cpp.persistence'),
+    filesystem: runtimeCapability('filesystem', 'native', 'cpp.filesystem'),
+    threading: runtimeCapability('threading', 'native', 'cpp.thread'),
+    dom: runtimeCapability('dom', 'unavailable', 'cpp.no-dom'),
+    async: runtimeCapability('async', 'adapter', 'cpp.async-runtime'),
+    ffi: runtimeCapability('ffi', 'native', 'cpp.abi')
+  }, ['cc', 'cxx', 'hpp'])
+]);
+
+function runtimeHostProfile(id, language, runtime, host, target, capabilities, aliases = []) {
+  return Object.freeze({
+    id,
+    language,
+    aliases,
+    runtime,
+    host,
+    target,
+    capabilities: freezeCapabilityMap(capabilities),
+    notes: []
+  });
+}
+
+function runtimeCapability(kind, support, binding, notes = []) {
+  return Object.freeze({
+    kind,
+    support,
+    binding,
+    notes
+  });
+}
+
+function freezeCapabilityMap(capabilities) {
+  return Object.freeze(Object.fromEntries(Object.entries(capabilities).map(([key, value]) => [key, Object.freeze(value)])));
+}