reset-framework-cli 1.1.4 → 1.2.0

package/src/lib/project.js

@@ -3,7 +3,34 @@ import { createRequire } from "node:module"
 import path from "node:path"
 import { fileURLToPath } from "node:url"
 
-const require = createRequire(import.meta.url)
+const require = createRequire(import.meta.url)
+
+const runtimePackageDescriptors = [
+  {
+    packageName: "@reset-framework/runtime-darwin-arm64",
+    workspaceDirName: "runtime-darwin-arm64",
+    platform: "darwin",
+    arch: "arm64",
+    artifactRootSegments: ["dist", "darwin-arm64", "reset-framework.app"],
+    binarySegments: ["dist", "darwin-arm64", "reset-framework.app", "Contents", "MacOS", "reset-framework"]
+  },
+  {
+    packageName: "@reset-framework/runtime-darwin-x64",
+    workspaceDirName: "runtime-darwin-x64",
+    platform: "darwin",
+    arch: "x64",
+    artifactRootSegments: ["dist", "darwin-x64", "reset-framework.app"],
+    binarySegments: ["dist", "darwin-x64", "reset-framework.app", "Contents", "MacOS", "reset-framework"]
+  },
+  {
+    packageName: "@reset-framework/runtime-win32-x64",
+    workspaceDirName: "runtime-win32-x64",
+    platform: "win32",
+    arch: "x64",
+    artifactRootSegments: ["dist", "win32-x64"],
+    binarySegments: ["dist", "win32-x64", "reset-framework.exe"]
+  }
+]
 
 function requireString(object, key, scope) {
   if (typeof object?.[key] !== "string" || object[key].trim() === "") {
@@ -107,29 +134,29 @@ function toTitleCase(value) {
     .join(" ") || "Reset App"
 }
 
-function readJsonFile(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"))
-}
-
-function fileExists(filePath) {
-  return existsSync(filePath)
-}
-
-function getFrameworkBuildType(mode) {
-  return mode === "release" ? "Release" : "Debug"
-}
-
-function resolveExistingCandidate(candidates) {
-  return candidates.find((candidate) => existsSync(candidate)) ?? null
-}
+function readJsonFile(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"))
+}
+
+function fileExists(filePath) {
+  return existsSync(filePath)
+}
+
+function getFrameworkBuildType(mode) {
+  return mode === "release" ? "Release" : "Debug"
+}
+
+function resolveExistingCandidate(candidates) {
+  return candidates.find((candidate) => existsSync(candidate)) ?? null
+}
 
 function isPathInside(parentDir, candidatePath) {
   const relative = path.relative(parentDir, candidatePath)
   return relative !== "" && !relative.startsWith("..") && !path.isAbsolute(relative)
 }
 
-function resolvePackageInfo(packageName, fallbackRoot) {
-  try {
+function resolvePackageInfo(packageName, fallbackRoot) {
+  try {
     const packageJsonPath = require.resolve(`${packageName}/package.json`)
     const packageRoot = path.dirname(packageJsonPath)
     const manifest = readJsonFile(packageJsonPath)
@@ -152,10 +179,10 @@ function resolvePackageInfo(packageName, fallbackRoot) {
       version: manifest.version ?? "0.0.0",
       localFallback: true
     }
-  }
-}
-
-function resolveWorkspacePackageInfo(packageName, workspaceRoot, fallbackInfo) {
+  }
+}
+
+function resolveWorkspacePackageInfo(packageName, workspaceRoot, fallbackInfo) {
   const packageJsonPath = path.join(workspaceRoot, "package.json")
 
   if (!existsSync(packageJsonPath)) {
@@ -164,157 +191,360 @@ function resolveWorkspacePackageInfo(packageName, workspaceRoot, fallbackInfo) {
 
   const manifest = readJsonFile(packageJsonPath)
 
-  return {
-    packageName: manifest.name ?? packageName,
-    packageRoot: workspaceRoot,
-    packageJsonPath,
-    version: manifest.version ?? fallbackInfo.version,
-    localFallback: true
-  }
-}
-
-export function resolveFrameworkPaths() {
-  const moduleDir = path.dirname(fileURLToPath(import.meta.url))
-  const cliDir = path.resolve(moduleDir, "../..")
-  const packagesDir = path.resolve(cliDir, "..")
-  const cliPackageJsonPath = path.join(cliDir, "package.json")
-  const cliManifest = readJsonFile(cliPackageJsonPath)
-  const nativePackage = resolveWorkspacePackageInfo(
-    "@reset-framework/native",
-    path.join(packagesDir, "native"),
-    resolvePackageInfo("@reset-framework/native", path.join(packagesDir, "native"))
-  )
-  const sdkPackage = resolveWorkspacePackageInfo(
-    "@reset-framework/sdk",
-    path.join(packagesDir, "sdk"),
-    resolvePackageInfo("@reset-framework/sdk", path.join(packagesDir, "sdk"))
-  )
-  const schemaPackage = resolveWorkspacePackageInfo(
-    "@reset-framework/schema",
-    path.join(packagesDir, "schema"),
-    resolvePackageInfo("@reset-framework/schema", path.join(packagesDir, "schema"))
-  )
-  const isWorkspaceLayout = [nativePackage, sdkPackage, schemaPackage].every((pkg) =>
-    isPathInside(packagesDir, pkg.packageRoot)
+  return {
+    packageName: manifest.name ?? packageName,
+    packageRoot: workspaceRoot,
+    packageJsonPath,
+    version: manifest.version ?? fallbackInfo.version,
+    localFallback: true
+  }
+}
+
+function resolveOptionalPackageInfo(packageName, fallbackRoot) {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageRoot = path.dirname(packageJsonPath)
+    const manifest = readJsonFile(packageJsonPath)
+
+    return {
+      packageName: manifest.name ?? packageName,
+      packageRoot,
+      packageJsonPath,
+      version: manifest.version ?? "0.0.0",
+      localFallback: false
+    }
+  } catch {
+    const packageJsonPath = path.join(fallbackRoot, "package.json")
+
+    if (!existsSync(packageJsonPath)) {
+      return null
+    }
+
+    const manifest = readJsonFile(packageJsonPath)
+
+    return {
+      packageName: manifest.name ?? packageName,
+      packageRoot: fallbackRoot,
+      packageJsonPath,
+      version: manifest.version ?? "0.0.0",
+      localFallback: true
+    }
+  }
+}
+
+function resolveOptionalWorkspacePackageInfo(packageName, workspaceRoot, fallbackInfo) {
+  const packageJsonPath = path.join(workspaceRoot, "package.json")
+
+  if (!existsSync(packageJsonPath)) {
+    return fallbackInfo
+  }
+
+  const manifest = readJsonFile(packageJsonPath)
+  const version = fallbackInfo?.version ?? manifest.version ?? "0.0.0"
+
+  return {
+    packageName: manifest.name ?? packageName,
+    packageRoot: workspaceRoot,
+    packageJsonPath,
+    version,
+    localFallback: true
+  }
+}
+
+function resolveCurrentRuntimeDescriptor() {
+  return runtimePackageDescriptors.find(
+    (descriptor) =>
+      descriptor.platform === process.platform &&
+      descriptor.arch === process.arch
+  ) ?? null
+}
+
+function resolveRuntimePackage(packagesDir) {
+  const descriptor = resolveCurrentRuntimeDescriptor()
+
+  if (!descriptor) {
+    return null
+  }
+
+  const workspaceRoot = path.join(packagesDir, descriptor.workspaceDirName)
+  const packageInfo = resolveOptionalWorkspacePackageInfo(
+    descriptor.packageName,
+    workspaceRoot,
+    resolveOptionalPackageInfo(descriptor.packageName, workspaceRoot)
+  )
+
+  return {
+    descriptor,
+    packageInfo,
+    artifactRoot: packageInfo ? path.join(packageInfo.packageRoot, ...descriptor.artifactRootSegments) : null,
+    binaryPath: packageInfo ? path.join(packageInfo.packageRoot, ...descriptor.binarySegments) : null
+  }
+}
+
+function hasSourceRuntimeLayout(frameworkPaths) {
+  return Boolean(
+    frameworkPaths.frameworkPackage &&
+    frameworkPaths.frameworkRoot &&
+    frameworkPaths.runtimeDir &&
+    frameworkPaths.rootCMakePath &&
+    frameworkPaths.vcpkgManifestPath &&
+    existsSync(frameworkPaths.frameworkPackage.packageJsonPath) &&
+    existsSync(frameworkPaths.frameworkRoot) &&
+    existsSync(frameworkPaths.runtimeDir) &&
+    existsSync(frameworkPaths.rootCMakePath) &&
+    existsSync(frameworkPaths.vcpkgManifestPath)
+  )
+}
+
+function isSourceRuntimeRequested(options = {}) {
+  if (options.preferSource === true) {
+    return true
+  }
+
+  const raw = process.env.RESET_FRAMEWORK_RUNTIME_SOURCE
+  if (typeof raw !== "string") {
+    return false
+  }
+
+  return ["1", "true", "yes", "on", "source"].includes(raw.trim().toLowerCase())
+}
+
+export function resolveFrameworkPaths() {
+  const moduleDir = path.dirname(fileURLToPath(import.meta.url))
+  const cliDir = path.resolve(moduleDir, "../..")
+  const packagesDir = path.resolve(cliDir, "..")
+  const isWorkspacePackagesDir = path.basename(packagesDir) === "packages"
+  const cliPackageJsonPath = path.join(cliDir, "package.json")
+  const cliManifest = readJsonFile(cliPackageJsonPath)
+  const nativePackage = resolveOptionalWorkspacePackageInfo(
+    "@reset-framework/native",
+    path.join(packagesDir, "native"),
+    resolveOptionalPackageInfo("@reset-framework/native", path.join(packagesDir, "native"))
+  )
+  const sdkPackage = resolveWorkspacePackageInfo(
+    "@reset-framework/sdk",
+    path.join(packagesDir, "sdk"),
+    resolvePackageInfo("@reset-framework/sdk", path.join(packagesDir, "sdk"))
   )
-
-  return {
-    cliDir,
-    cliPackage: {
-      packageName: cliManifest.name,
-      packageRoot: cliDir,
-      packageJsonPath: cliPackageJsonPath,
-      version: cliManifest.version ?? "0.0.0",
-      localFallback: true
-    },
-    packagesDir,
-    frameworkRoot: nativePackage.packageRoot,
-    frameworkPackage: nativePackage,
-    isWorkspaceLayout,
-    sdkPackage,
-    schemaPackage,
-    runtimeDir: path.join(nativePackage.packageRoot, "runtime"),
-    rootCMakePath: path.join(nativePackage.packageRoot, "CMakeLists.txt"),
-    cmakePresetsPath: path.join(nativePackage.packageRoot, "CMakePresets.json"),
-    vcpkgManifestPath: path.join(nativePackage.packageRoot, "vcpkg.json"),
-    templatesDir: path.join(cliDir, "templates"),
-  }
-}
+  const schemaPackage = resolveWorkspacePackageInfo(
+    "@reset-framework/schema",
+    path.join(packagesDir, "schema"),
+    resolvePackageInfo("@reset-framework/schema", path.join(packagesDir, "schema"))
+  )
+  const runtimePackage = resolveRuntimePackage(packagesDir)
+  const isWorkspaceLayout =
+    isWorkspacePackagesDir &&
+    [cliDir, sdkPackage.packageRoot, schemaPackage.packageRoot].every((packageRoot) =>
+      isPathInside(packagesDir, packageRoot)
+    )
+
+  return {
+    cliDir,
+    cliPackage: {
+      packageName: cliManifest.name,
+      packageRoot: cliDir,
+      packageJsonPath: cliPackageJsonPath,
+      version: cliManifest.version ?? "0.0.0",
+      localFallback: isWorkspaceLayout
+    },
+    packagesDir,
+    frameworkRoot: nativePackage?.packageRoot ?? null,
+    frameworkPackage: nativePackage,
+    isWorkspaceLayout,
+    sdkPackage,
+    schemaPackage,
+    runtimePackage,
+    runtimeDir: nativePackage ? path.join(nativePackage.packageRoot, "runtime") : null,
+    rootCMakePath: nativePackage ? path.join(nativePackage.packageRoot, "CMakeLists.txt") : null,
+    cmakePresetsPath: nativePackage ? path.join(nativePackage.packageRoot, "CMakePresets.json") : null,
+    vcpkgManifestPath: nativePackage ? path.join(nativePackage.packageRoot, "vcpkg.json") : null,
+    templatesDir: path.join(cliDir, "templates")
+  }
+}
 
 export function resolveFrameworkBuildPaths(appPaths) {
-  const frameworkCacheRoot = path.join(appPaths.appRoot, ".reset", "framework")
-  const isWindows = process.platform === "win32"
-  const devRuntimeRoot = path.join(frameworkCacheRoot, "build", "dev", "runtime")
-  const releaseRuntimeRoot = path.join(frameworkCacheRoot, "build", "release", "runtime")
-  const devAppBinaryCandidates = isWindows
-    ? [
-        path.join(devRuntimeRoot, getFrameworkBuildType("dev"), "reset-framework.exe"),
-        path.join(devRuntimeRoot, "reset-framework.exe")
-      ]
-    : [
-        path.join(
-          frameworkCacheRoot,
-          "build",
-          "dev",
-          "runtime",
-          "reset-framework.app",
-          "Contents",
-          "MacOS",
-          "reset-framework"
-        )
-      ]
-  const releaseAppBinaryCandidates = isWindows
-    ? [
-        path.join(releaseRuntimeRoot, getFrameworkBuildType("release"), "reset-framework.exe"),
-        path.join(releaseRuntimeRoot, "reset-framework.exe")
-      ]
-    : [
-        path.join(
-          frameworkCacheRoot,
-          "build",
-          "release",
-          "runtime",
-          "reset-framework.app"
-        )
-      ]
+  const frameworkCacheRoot = path.join(appPaths.appRoot, ".reset", "framework")
+  const isWindows = process.platform === "win32"
+  const devRuntimeRoot = path.join(frameworkCacheRoot, "build", "dev", "runtime")
+  const releaseRuntimeRoot = path.join(frameworkCacheRoot, "build", "release", "runtime")
+  const devAppBinaryCandidates = isWindows
+    ? [
+        path.join(devRuntimeRoot, getFrameworkBuildType("dev"), "reset-framework.exe"),
+        path.join(devRuntimeRoot, "reset-framework.exe")
+      ]
+    : [
+        path.join(
+          frameworkCacheRoot,
+          "build",
+          "dev",
+          "runtime",
+          "reset-framework.app",
+          "Contents",
+          "MacOS",
+          "reset-framework"
+        )
+      ]
+  const releaseAppBinaryCandidates = isWindows
+    ? [
+        path.join(releaseRuntimeRoot, getFrameworkBuildType("release"), "reset-framework.exe"),
+        path.join(releaseRuntimeRoot, "reset-framework.exe")
+      ]
+    : [
+        path.join(
+          frameworkCacheRoot,
+          "build",
+          "release",
+          "runtime",
+          "reset-framework.app"
+        )
+      ]
+
+  return {
+    frameworkCacheRoot,
+    devBuildDir: path.join(frameworkCacheRoot, "build", "dev"),
+    releaseBuildDir: path.join(frameworkCacheRoot, "build", "release"),
+    devRuntimeOutputCandidates: isWindows
+      ? [path.join(devRuntimeRoot, getFrameworkBuildType("dev")), devRuntimeRoot]
+      : [path.join(frameworkCacheRoot, "build", "dev", "runtime", "reset-framework.app")],
+    releaseRuntimeOutputCandidates: isWindows
+      ? [path.join(releaseRuntimeRoot, getFrameworkBuildType("release")), releaseRuntimeRoot]
+      : [path.join(frameworkCacheRoot, "build", "release", "runtime", "reset-framework.app")],
+    devAppBinaryCandidates,
+    releaseAppBinaryCandidates,
+    devAppBinary: devAppBinaryCandidates[0],
+    releaseAppTemplate: releaseAppBinaryCandidates[0]
+  }
+}
 
-  return {
-    frameworkCacheRoot,
-    devBuildDir: path.join(frameworkCacheRoot, "build", "dev"),
-    releaseBuildDir: path.join(frameworkCacheRoot, "build", "release"),
-    devRuntimeOutputCandidates: isWindows
-      ? [path.join(devRuntimeRoot, getFrameworkBuildType("dev")), devRuntimeRoot]
-      : [path.join(frameworkCacheRoot, "build", "dev", "runtime", "reset-framework.app")],
-    releaseRuntimeOutputCandidates: isWindows
-      ? [path.join(releaseRuntimeRoot, getFrameworkBuildType("release")), releaseRuntimeRoot]
-      : [path.join(frameworkCacheRoot, "build", "release", "runtime", "reset-framework.app")],
-    devAppBinaryCandidates,
-    releaseAppBinaryCandidates,
-    devAppBinary: devAppBinaryCandidates[0],
-    releaseAppTemplate: releaseAppBinaryCandidates[0]
+export function resolveFrameworkRuntimeStrategy(frameworkPaths, options = {}) {
+  const sourceRequested = isSourceRuntimeRequested(options)
+  const runtimePackage = frameworkPaths.runtimePackage
+  const hasPrebuiltRuntime =
+    Boolean(runtimePackage?.packageInfo) &&
+    Boolean(runtimePackage?.artifactRoot) &&
+    Boolean(runtimePackage?.binaryPath) &&
+    existsSync(runtimePackage.artifactRoot) &&
+    existsSync(runtimePackage.binaryPath)
+  const hasSourceRuntime = hasSourceRuntimeLayout(frameworkPaths)
+
+  if (sourceRequested) {
+    if (!hasSourceRuntime) {
+      throw new Error(
+        "Source runtime was requested, but @reset-framework/native is not installed in this CLI environment."
+      )
+    }
+
+    return {
+      kind: "source",
+      packageInfo: frameworkPaths.frameworkPackage,
+      label: `${frameworkPaths.frameworkPackage.packageName}@${frameworkPaths.frameworkPackage.version}`
+    }
+  }
+
+  if (hasPrebuiltRuntime) {
+    return {
+      kind: "prebuilt",
+      packageInfo: runtimePackage.packageInfo,
+      descriptor: runtimePackage.descriptor,
+      artifactRoot: runtimePackage.artifactRoot,
+      binaryPath: runtimePackage.binaryPath,
+      label: `${runtimePackage.packageInfo.packageName}@${runtimePackage.packageInfo.version}`
+    }
+  }
+
+  if (hasSourceRuntime) {
+    return {
+      kind: "source",
+      packageInfo: frameworkPaths.frameworkPackage,
+      label: `${frameworkPaths.frameworkPackage.packageName}@${frameworkPaths.frameworkPackage.version}`
+    }
+  }
+
+  if (runtimePackage?.packageInfo) {
+    throw new Error(
+      `Installed runtime package ${runtimePackage.packageInfo.packageName} is missing bundled runtime artifacts under ${runtimePackage.artifactRoot}.`
+    )
   }
+
+  if (runtimePackage?.descriptor) {
+    throw new Error(
+      `No bundled runtime package is installed for ${process.platform}-${process.arch}. Expected ${runtimePackage.descriptor.packageName}.`
+    )
+  }
+
+  throw new Error(
+    `Reset Framework does not currently provide a bundled runtime for ${process.platform}-${process.arch}.`
+  )
 }
 
-export function resolveFrameworkRuntimeBinary(frameworkBuildPaths, mode, options = {}) {
+export function resolveFrameworkRuntimeBinary(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
   const { mustExist = false } = options
+  const strategy = options.strategy ?? resolveFrameworkRuntimeStrategy(frameworkPaths, options)
+
+  if (strategy.kind === "prebuilt") {
+    if (existsSync(strategy.binaryPath)) {
+      return strategy.binaryPath
+    }
+
+    if (mustExist) {
+      throw new Error(`Missing bundled runtime executable at ${strategy.binaryPath}.`)
+    }
+
+    return strategy.binaryPath
+  }
+
   const candidates =
     mode === "release"
       ? (frameworkBuildPaths.releaseAppBinaryCandidates ?? [frameworkBuildPaths.releaseAppTemplate])
       : (frameworkBuildPaths.devAppBinaryCandidates ?? [frameworkBuildPaths.devAppBinary])
-  const existing = resolveExistingCandidate(candidates)
-
-  if (existing) {
-    return existing
-  }
-
-  if (mustExist) {
-    throw new Error(`Missing built runtime executable. Looked in: ${candidates.join(", ")}`)
-  }
+  const existing = resolveExistingCandidate(candidates)
+
+  if (existing) {
+    return existing
+  }
+
+  if (mustExist) {
+    throw new Error(`Missing built runtime executable. Looked in: ${candidates.join(", ")}`)
+  }
 
   return candidates[0]
 }
 
-export function resolveFrameworkRuntimeOutputDir(frameworkBuildPaths, mode, options = {}) {
+export function resolveFrameworkRuntimeOutputDir(frameworkPaths, frameworkBuildPaths, mode, options = {}) {
   const { mustExist = false } = options
-  const candidates =
-    mode === "release"
-      ? (frameworkBuildPaths.releaseRuntimeOutputCandidates ?? [])
-      : (frameworkBuildPaths.devRuntimeOutputCandidates ?? [])
-  const existing = resolveExistingCandidate(candidates)
+  const strategy = options.strategy ?? resolveFrameworkRuntimeStrategy(frameworkPaths, options)
 
-  if (existing) {
-    return existing
-  }
+  if (strategy.kind === "prebuilt") {
+    if (existsSync(strategy.artifactRoot)) {
+      return strategy.artifactRoot
+    }
 
-  if (candidates.length > 0) {
     if (mustExist) {
-      throw new Error(`Missing built runtime output directory. Looked in: ${candidates.join(", ")}`)
+      throw new Error(`Missing bundled runtime output directory at ${strategy.artifactRoot}.`)
     }
 
-    return candidates[0]
+    return strategy.artifactRoot
   }
 
-  return path.dirname(resolveFrameworkRuntimeBinary(frameworkBuildPaths, mode, options))
+  const candidates =
+    mode === "release"
+      ? (frameworkBuildPaths.releaseRuntimeOutputCandidates ?? [])
+      : (frameworkBuildPaths.devRuntimeOutputCandidates ?? [])
+  const existing = resolveExistingCandidate(candidates)
+
+  if (existing) {
+    return existing
+  }
+
+  if (candidates.length > 0) {
+    if (mustExist) {
+      throw new Error(`Missing built runtime output directory. Looked in: ${candidates.join(", ")}`)
+    }
+
+    return candidates[0]
+  }
+
+  return path.dirname(resolveFrameworkRuntimeBinary(frameworkPaths, frameworkBuildPaths, mode, options))
 }
 
 export function resolveAppPaths(appRoot) {
@@ -339,33 +569,94 @@ export function resolveConfigPath(appPaths) {
   return appPaths.resetConfigPath
 }
 
-export function getFrameworkChecks(frameworkPaths) {
-  return [
-    ["native", frameworkPaths.frameworkPackage.packageJsonPath],
-    ["sdk", frameworkPaths.sdkPackage.packageJsonPath],
-    ["schema", frameworkPaths.schemaPackage.packageJsonPath],
-    ["cmake", frameworkPaths.rootCMakePath],
-    ["runtime", frameworkPaths.runtimeDir],
-    ["vcpkg", frameworkPaths.vcpkgManifestPath],
-    ["templates", frameworkPaths.templatesDir]
-  ]
-}
-
-export function getAppChecks(appPaths) {
-  return [["config", resolveConfigPath(appPaths)]]
-}
-
-export function assertFrameworkInstall(frameworkPaths) {
-  const missing = getFrameworkChecks(frameworkPaths)
-    .filter(([, filePath]) => !existsSync(filePath))
-    .map(([label]) => label)
-
-  if (missing.length > 0) {
-    throw new Error(
-      `Reset CLI installation is incomplete. Missing: ${missing.join(", ")}`
-    )
-  }
-}
+export function getFrameworkChecks(frameworkPaths) {
+  return [
+    ["sdk", frameworkPaths.sdkPackage.packageJsonPath],
+    ["schema", frameworkPaths.schemaPackage.packageJsonPath],
+    ["templates", frameworkPaths.templatesDir]
+  ]
+}
+
+export function getFrameworkRuntimeChecks(frameworkPaths) {
+  const checks = []
+
+  if (frameworkPaths.runtimePackage?.packageInfo) {
+    checks.push(["runtime package", frameworkPaths.runtimePackage.packageInfo.packageJsonPath])
+    if (frameworkPaths.runtimePackage.artifactRoot) {
+      checks.push(["runtime artifact", frameworkPaths.runtimePackage.artifactRoot])
+    }
+  }
+
+  if (frameworkPaths.frameworkPackage) {
+    checks.push(["native source", frameworkPaths.frameworkPackage.packageJsonPath])
+  }
+
+  if (frameworkPaths.rootCMakePath) {
+    checks.push(["cmake", frameworkPaths.rootCMakePath])
+  }
+
+  if (frameworkPaths.runtimeDir) {
+    checks.push(["runtime source", frameworkPaths.runtimeDir])
+  }
+
+  if (frameworkPaths.vcpkgManifestPath) {
+    checks.push(["vcpkg", frameworkPaths.vcpkgManifestPath])
+  }
+
+  return checks
+}
+
+export function getFrameworkRuntimeModeSummary(frameworkPaths, options = {}) {
+  const strategy = resolveFrameworkRuntimeStrategy(frameworkPaths, options)
+
+  return {
+    kind: strategy.kind,
+    label: strategy.label
+  }
+}
+
+export function hasFrameworkSourcePackage(frameworkPaths) {
+  return hasSourceRuntimeLayout(frameworkPaths)
+}
+
+export function isFrameworkSourceRequested(options = {}) {
+  return isSourceRuntimeRequested(options)
+}
+
+export function assertFrameworkInstall(frameworkPaths) {
+  const missing = getFrameworkChecks(frameworkPaths)
+    .filter(([, filePath]) => !existsSync(filePath))
+    .map(([label]) => label)
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Reset CLI installation is incomplete. Missing: ${missing.join(", ")}`
+    )
+  }
+}
+
+export function assertFrameworkSourceInstall(frameworkPaths) {
+  const missing = [
+    ["native source", frameworkPaths.frameworkPackage?.packageJsonPath],
+    ["sdk", frameworkPaths.sdkPackage.packageJsonPath],
+    ["cmake", frameworkPaths.rootCMakePath],
+    ["runtime", frameworkPaths.runtimeDir],
+    ["vcpkg", frameworkPaths.vcpkgManifestPath],
+    ["templates", frameworkPaths.templatesDir]
+  ]
+    .filter(([, filePath]) => !filePath || !existsSync(filePath))
+    .map(([label]) => label)
+
+  if (missing.length > 0) {
+    throw new Error(
+      `Source runtime is unavailable in this CLI installation. Missing: ${missing.join(", ")}`
+    )
+  }
+}
+
+export function getAppChecks(appPaths) {
+  return [["config", resolveConfigPath(appPaths)]]
+}
 
 export function assertAppProject(appPaths, config) {
   const checks = [...getAppChecks(appPaths)]
@@ -471,39 +762,39 @@ export function loadResetConfig(appPaths) {
   }
 }
 
-export function resolveAppOutputPaths(appPaths, config) {
-  const outputRoot = path.resolve(appPaths.appRoot, config.build.outputDir)
-  const frontendDir = resolveFrontendDir(appPaths, config)
-  const isWindows = process.platform === "win32"
-  const appBundleName = isWindows ? config.productName : `${config.productName}.app`
-  const platformDir = path.join(outputRoot, isWindows ? "windows" : "macos")
-  const appBundlePath = path.join(platformDir, appBundleName)
-  const resourcesDir = isWindows
-    ? path.join(appBundlePath, "resources")
-    : path.join(appBundlePath, "Contents", "Resources")
-  const packagesDir = path.join(outputRoot, "packages")
-
-  return {
-    outputRoot,
-    macosDir: isWindows ? undefined : platformDir,
-    windowsDir: isWindows ? platformDir : undefined,
-    appBundlePath,
-    appExecutablePath: isWindows
-      ? path.join(appBundlePath, `${config.productName}.exe`)
-      : undefined,
-    resourcesDir,
-    bundledConfigPath: path.join(resourcesDir, "reset.config.json"),
-    bundledFrontendDir: path.join(resourcesDir, config.frontend.distDir),
-    frontendDistDir: path.resolve(frontendDir, config.frontend.distDir),
-    frontendEntryFile: path.resolve(
+export function resolveAppOutputPaths(appPaths, config) {
+  const outputRoot = path.resolve(appPaths.appRoot, config.build.outputDir)
+  const frontendDir = resolveFrontendDir(appPaths, config)
+  const isWindows = process.platform === "win32"
+  const appBundleName = isWindows ? config.productName : `${config.productName}.app`
+  const platformDir = path.join(outputRoot, isWindows ? "windows" : "macos")
+  const appBundlePath = path.join(platformDir, appBundleName)
+  const resourcesDir = isWindows
+    ? path.join(appBundlePath, "resources")
+    : path.join(appBundlePath, "Contents", "Resources")
+  const packagesDir = path.join(outputRoot, "packages")
+
+  return {
+    outputRoot,
+    macosDir: isWindows ? undefined : platformDir,
+    windowsDir: isWindows ? platformDir : undefined,
+    appBundlePath,
+    appExecutablePath: isWindows
+      ? path.join(appBundlePath, `${config.productName}.exe`)
+      : undefined,
+    resourcesDir,
+    bundledConfigPath: path.join(resourcesDir, "reset.config.json"),
+    bundledFrontendDir: path.join(resourcesDir, config.frontend.distDir),
+    frontendDistDir: path.resolve(frontendDir, config.frontend.distDir),
+    frontendEntryFile: path.resolve(
       frontendDir,
       config.frontend.distDir,
       config.frontend.entryHtml
-    ),
-    packagesDir,
-    zipPath: path.join(packagesDir, `${config.name}-${isWindows ? "windows" : "macos"}.zip`)
-  }
-}
+    ),
+    packagesDir,
+    zipPath: path.join(packagesDir, `${config.name}-${isWindows ? "windows" : "macos"}.zip`)
+  }
+}
 
 export function resolveFrontendDir(appPaths, config) {
   return path.resolve(appPaths.appRoot, config.project.frontendDir)