@shapeshift-labs/frontier-lang-compiler 0.2.65 → 0.2.67

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)])));
+}

package/dist/universal-runtime-route-records.js

@@ -0,0 +1,162 @@
+import {
+  idFragment,
+  uniqueStrings
+} from './native-import-utils.js';
+
+export function runtimeRoute(sourceHost, targetHost, input) {
+  const requiredCapabilities = requirementsForRoute(input.requirements, sourceHost, targetHost);
+  const requirementRows = requiredCapabilities.map((capability) => runtimeCapabilityRequirement(capability, sourceHost, targetHost, input));
+  const adapterRequirements = requirementRows.filter((row) => row.adapterRequired).map((row) => row.adapterRequirement);
+  const satisfiedCapabilities = requirementRows.filter((row) => !row.adapterRequired).map((row) => row.capability);
+  const missingCapabilities = requirementRows.filter((row) => row.targetSupport === 'unavailable').map((row) => row.capability);
+  const blockers = requirementRows.filter((row) => row.sourceSupport === 'unavailable')
+    .map((row) => `Source host ${sourceHost.id} does not declare required runtime capability ${row.capability}.`);
+  const review = adapterRequirements.map((requirement) => requirement.reason);
+  const id = `runtime_${idFragment(sourceHost.id)}_to_${idFragment(targetHost.id)}_${idFragment(targetHost.target)}`;
+  return {
+    id,
+    source: runtimeHostSummary(sourceHost),
+    target: runtimeHostSummary(targetHost),
+    requiredCapabilities,
+    satisfiedCapabilities,
+    adapterRequirements,
+    missingCapabilities,
+    readiness: blockers.length ? 'blocked' : adapterRequirements.length ? 'needs-review' : 'ready',
+    blockers,
+    review: uniqueStrings(review),
+    metadata: {
+      generatedAt: input.generatedAt,
+      note: 'Runtime adapter requirements describe host API obligations only; parser, syntax, and target-projection evidence remain separate.'
+    }
+  };
+}
+
+function requirementsForRoute(requirements, sourceHost, targetHost) {
+  return uniqueStrings((requirements ?? []).filter((requirement) => requirementApplies(requirement, sourceHost, targetHost))
+    .map((requirement) => requirement.capability));
+}
+
+function requirementApplies(requirement, sourceHost, targetHost) {
+  if (requirement.sourceHostId && requirement.sourceHostId !== sourceHost.id) return false;
+  if (requirement.targetHostId && requirement.targetHostId !== targetHost.id) return false;
+  if (requirement.sourceLanguage && !sourceHost.languageIds.includes(requirement.sourceLanguage)) return false;
+  if (requirement.sourceRuntime && requirement.sourceRuntime !== sourceHost.runtime && requirement.sourceRuntime !== sourceHost.id) return false;
+  if (requirement.target && requirement.target !== targetHost.target) return false;
+  if (requirement.targetRuntime && requirement.targetRuntime !== targetHost.runtime && requirement.targetRuntime !== targetHost.id) return false;
+  return Boolean(requirement.capability);
+}
+
+function runtimeCapabilityRequirement(capability, sourceHost, targetHost, input) {
+  const sourceCapability = sourceHost.capabilities[capability] ?? unavailableCapability(capability, sourceHost.id);
+  const targetCapability = targetHost.capabilities[capability] ?? unavailableCapability(capability, targetHost.id);
+  const compatible = runtimeCapabilityCompatible(sourceHost, targetHost, sourceCapability, targetCapability);
+  const reason = runtimeAdapterReason(capability, sourceHost, targetHost, sourceCapability, targetCapability);
+  return {
+    capability,
+    sourceSupport: sourceCapability.support,
+    targetSupport: targetCapability.support,
+    sourceBinding: sourceCapability.binding,
+    targetBinding: targetCapability.binding,
+    adapterRequired: !compatible,
+    adapterRequirement: compatible ? undefined : {
+      id: `runtime_adapter_${idFragment(sourceHost.id)}_${idFragment(targetHost.id)}_${idFragment(capability)}`,
+      capability,
+      adapterKind: runtimeAdapterKind(capability, sourceHost, targetHost),
+      sourceHost: sourceHost.id,
+      targetHost: targetHost.id,
+      sourceBinding: sourceCapability.binding,
+      targetBinding: targetCapability.binding,
+      required: true,
+      reason,
+      evidenceIds: uniqueStrings(input.requirements
+        .filter((requirement) => requirement.capability === capability && requirementApplies(requirement, sourceHost, targetHost))
+        .flatMap((requirement) => requirement.evidenceIds ?? []))
+    }
+  };
+}
+
+function runtimeCapabilityCompatible(sourceHost, targetHost, sourceCapability, targetCapability) {
+  if (sourceHost.id === targetHost.id) return true;
+  if (sourceCapability.support === 'unavailable' || targetCapability.support === 'unavailable') return false;
+  return sourceCapability.binding === targetCapability.binding;
+}
+
+function unavailableCapability(kind, hostId) {
+  return {
+    kind,
+    support: 'unavailable',
+    binding: `${hostId}.${kind}.unavailable`,
+    notes: []
+  };
+}
+
+function runtimeHostSummary(host) {
+  return {
+    id: host.id,
+    language: host.language,
+    aliases: host.aliases,
+    languageIds: host.languageIds,
+    runtime: host.runtime,
+    host: host.host,
+    target: host.target,
+    capabilities: host.capabilities
+  };
+}
+
+function runtimeAdapterKind(capability, sourceHost, targetHost) {
+  if (capability === 'fetch' && sourceHost.runtime === 'web' && targetHost.runtime === 'cli') return 'browser-fetch-to-cli-http-client';
+  if (capability === 'fetch' && sourceHost.runtime === 'cli' && targetHost.runtime === 'web') return 'cli-http-client-to-browser-fetch';
+  if (capability === 'timers') return `${sourceHost.runtime}-timers-to-${targetHost.runtime}-timers`;
+  if (capability === 'storage' && targetHost.runtime === 'cli') return 'browser-storage-to-cli-persistence';
+  if (capability === 'storage' && targetHost.runtime === 'web') return 'cli-storage-to-browser-storage';
+  if (capability === 'filesystem' && targetHost.runtime === 'web') return 'filesystem-to-browser-storage';
+  if (capability === 'filesystem') return `${sourceHost.runtime}-filesystem-to-${targetHost.runtime}-filesystem`;
+  if (capability === 'threading' && targetHost.runtime === 'web') return 'native-threading-to-web-workers';
+  if (capability === 'threading') return `${sourceHost.runtime}-threading-to-${targetHost.runtime}-threading`;
+  if (capability === 'dom' && targetHost.runtime === 'cli') return 'dom-to-headless-host';
+  if (capability === 'dom') return `${sourceHost.runtime}-dom-to-${targetHost.runtime}-dom`;
+  if (capability === 'async') return `${sourceHost.runtime}-async-to-${targetHost.runtime}-async`;
+  if (capability === 'ffi' && targetHost.runtime === 'web') return 'native-ffi-to-web-boundary';
+  if (capability === 'ffi') return `${sourceHost.runtime}-ffi-to-${targetHost.runtime}-ffi`;
+  return `${sourceHost.runtime}-${capability}-to-${targetHost.runtime}-${capability}`;
+}
+
+function runtimeAdapterReason(capability, sourceHost, targetHost, sourceCapability, targetCapability) {
+  if (targetCapability.support === 'unavailable') {
+    return `${sourceHost.id} requires ${capability}, but ${targetHost.id} does not provide a compatible host capability.`;
+  }
+  if (sourceCapability.support === 'unavailable') {
+    return `${sourceHost.id} declared ${capability}, but the source host profile marks it unavailable.`;
+  }
+  return `${sourceHost.id} uses ${sourceCapability.binding} for ${capability}; ${targetHost.id} exposes ${targetCapability.binding}, so a host adapter must preserve the runtime effect boundary.`;
+}
+
+export function runtimeCapabilityMatrixSummary(routes) {
+  const byReadiness = {};
+  const byCapability = {};
+  const byAdapterKind = {};
+  let adapterRequirements = 0;
+  let routesWithAdapters = 0;
+  let missingCapabilities = 0;
+  for (const route of routes) {
+    byReadiness[route.readiness] = (byReadiness[route.readiness] ?? 0) + 1;
+    if (route.adapterRequirements.length) routesWithAdapters += 1;
+    adapterRequirements += route.adapterRequirements.length;
+    missingCapabilities += route.missingCapabilities.length;
+    for (const capability of route.requiredCapabilities) {
+      byCapability[capability] = (byCapability[capability] ?? 0) + 1;
+    }
+    for (const requirement of route.adapterRequirements) {
+      byAdapterKind[requirement.adapterKind] = (byAdapterKind[requirement.adapterKind] ?? 0) + 1;
+    }
+  }
+  return {
+    routes: routes.length,
+    routesWithAdapters,
+    adapterRequirements,
+    missingCapabilities,
+    byReadiness,
+    byCapability,
+    byAdapterKind
+  };
+}

package/examples/js-frontier-rust-workbench-adapters.mjs

@@ -0,0 +1,89 @@
+export function createTsToRustWorkbenchAdapter() {
+  return {
+    id: 'frontier-lang-workbench-ts-to-rust',
+    sourceLanguage: 'typescript',
+    target: 'rust',
+    version: '0.0.0-demo',
+    capabilities: ['semantic-symbol-scaffold'],
+    coverage: {
+      readiness: 'ready',
+      handledLossKinds: ['opaqueNative', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
+      notes: ['Workbench adapter lowers TypeScript semantic symbols to Rust scaffolding and leaves bodies explicit.']
+    },
+    project(input) {
+      return {
+        output: rustFromSymbols(input.importResult.semanticIndex?.symbols ?? []),
+        readiness: 'ready',
+        evidence: [{
+          id: 'evidence_workbench_js_to_rust',
+          kind: 'projection',
+          status: 'passed',
+          summary: 'Workbench adapter projected TypeScript semantic symbols to Rust scaffolding.'
+        }]
+      };
+    }
+  };
+}
+
+export function createTsToPythonWorkbenchAdapter() {
+  return {
+    id: 'frontier-lang-workbench-ts-to-python',
+    sourceLanguage: 'typescript',
+    target: 'python',
+    version: '0.0.0-demo',
+    capabilities: ['semantic-symbol-scaffold'],
+    coverage: {
+      readiness: 'ready',
+      handledLossKinds: ['opaqueNative', 'declarationOnlyCoverage', 'partialSemanticIndex', 'sourceMapApproximation', 'sourcePreservation'],
+      notes: ['Workbench adapter lowers TypeScript semantic symbols to Python scaffolding and leaves bodies explicit.']
+    },
+    project(input) {
+      return {
+        output: pythonFromSymbols(input.importResult.semanticIndex?.symbols ?? []),
+        readiness: 'ready',
+        evidence: [{
+          id: 'evidence_workbench_js_to_python',
+          kind: 'projection',
+          status: 'passed',
+          summary: 'Workbench adapter projected TypeScript semantic symbols to Python scaffolding.'
+        }]
+      };
+    }
+  };
+}
+
+function rustFromSymbols(symbols) {
+  const lines = ['// Generated from Frontier semantic graph evidence.'];
+  for (const symbol of symbols) {
+    if (symbol.kind === 'class') lines.push('', `pub struct ${safeTypeName(symbol.name)};`);
+    if (symbol.kind === 'function' || symbol.kind === 'method') {
+      lines.push('', `pub fn ${safeRustName(symbol.name)}() {`, '    // port body from preserved TypeScript source', '}');
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function pythonFromSymbols(symbols) {
+  const lines = ['# Generated from Frontier semantic graph evidence.'];
+  for (const symbol of symbols) {
+    if (symbol.kind === 'type' || symbol.kind === 'class') lines.push('', `class ${safeTypeName(symbol.name)}:`, '    pass');
+    if (symbol.kind === 'function' || symbol.kind === 'method') {
+      lines.push('', `def ${safePythonName(symbol.name)}(*args):`, '    raise NotImplementedError("port body from preserved TypeScript source")');
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function safeTypeName(name) {
+  const clean = String(name).replace(/[^A-Za-z0-9_]/g, '');
+  return clean && /^[A-Z]/.test(clean) ? clean : `Frontier${clean || 'Type'}`;
+}
+
+function safeRustName(name) {
+  return String(name).replace(/\./g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[^A-Za-z0-9_]/g, '_').toLowerCase();
+}
+
+function safePythonName(name) {
+  const clean = String(name).replace(/\./g, '_').replace(/([a-z0-9])([A-Z])/g, '$1_$2').replace(/[^A-Za-z0-9_]/g, '_').toLowerCase();
+  return /^[A-Za-z_]/.test(clean) ? clean : `frontier_${clean}`;
+}

package/examples/js-frontier-rust-workbench-bounds.mjs

@@ -1,4 +1,5 @@
 export function conversionBounds(sourceLanguage, targetLanguage) {
+  const targetDisplay = String(targetLanguage).replace('/', ' and ');
   return {
     sourceLanguage,
     targetLanguage,
@@ -10,13 +11,13 @@ export function conversionBounds(sourceLanguage, targetLanguage) {
     ],
     reviewRequired: [
       'Function bodies are preserved as source evidence and emitted as TODO scaffolds.',
-      'Types are declaration evidence, not a full Rust trait/lifetime/ownership proof.',
+      `Types are declaration evidence, not a full ${targetDisplay} runtime or ownership proof.`,
       'Runtime APIs such as fetch, timers, storage, DOM, Node, and npm crates need adapters.',
       'Round trips are useful for review, but not automatic semantic equivalence proofs.'
     ],
     unsupportedToday: [
-      'Behavior-preserving transpilation of arbitrary TypeScript or Rust.',
-      'Full generic constraints, overload resolution, conditional types, macros, and borrow checking.',
+      'Behavior-preserving transpilation of arbitrary TypeScript into Rust or Python.',
+      'Full generic constraints, overload resolution, conditional types, macros, and ownership inference.',
       'Async control-flow lowering, exception/error model conversion, and memory ownership synthesis.',
       'Perfect comments/trivia formatting in projected target code without richer parser evidence.'
     ]