Nasiko ${version} is not qualified for ${normalized.os}/${no

Error message

Nasiko ${version} is not qualified for ${normalized.os}/${normalized.arch}.

What it means

getQualifiedRelease in scripts/lib/nasiko-release.js looks up the pinned digest table QUALIFIED_RELEASES[version][`${os}/${arch}`] after the version passed the 'vX.Y.Z' regex and the platform was normalized. An undefined result means either the version has no entry at all, or the version exists but lacks a build for this os/arch pair. Only versions whose digests were qualified at the time this file was shipped can install.

Source

Thrown at scripts/lib/nasiko-release.js:46

  }),
});

function normalizePlatform(platform = process.platform, architecture = process.arch) {
  const osName = platform === 'win32' ? 'windows' : platform;
  if (!['linux', 'darwin', 'windows'].includes(osName)) throw new Error(`Unsupported platform: ${platform}`);
  const arch = architecture === 'x64' ? 'amd64' : architecture;
  if (!['amd64', 'arm64'].includes(arch)) throw new Error(`Unsupported architecture: ${architecture}`);
  if (osName === 'windows' && arch !== 'amd64') throw new Error(`Unsupported architecture for Windows: ${architecture}`);
  return { os: osName, arch, binaryName: osName === 'windows' ? 'nasiko.exe' : 'nasiko' };
}

function getQualifiedRelease(version, platform = process.platform, architecture = process.arch) {
  if (!/^v\d+\.\d+\.\d+$/.test(String(version || ''))) {
    throw new Error('Nasiko installation requires a pinned version such as v0.1.0; latest is not allowed.');
  }
  const normalized = normalizePlatform(platform, architecture);
  const qualification = QUALIFIED_RELEASES[version]?.[`${normalized.os}/${normalized.arch}`];
  if (!qualification) throw new Error(`Nasiko ${version} is not qualified for ${normalized.os}/${normalized.arch}.`);
  return { version, ...normalized, ...qualification, license: LICENSE, sourceUrl: SOURCE_URL };
}

function digestBytes(bytes) {
  return `sha256:${crypto.createHash('sha256').update(bytes).digest('hex')}`;
}

function assertDigest(bytes, expectedDigest, label) {
  if (!SHA256_PATTERN.test(expectedDigest)) throw new Error(`${label} has an invalid expected digest.`);
  const actual = digestBytes(bytes);
  if (actual !== expectedDigest) throw new Error(`${label} digest mismatch: expected ${expectedDigest}, got ${actual}.`);
}

function validateManifest(bytes) {
  let manifest;
  try { manifest = JSON.parse(bytes.toString('utf8')); } catch (_error) { throw new Error('Nasiko manifest is not valid JSON.'); }
  if (manifest.schemaVersion !== 2 || !Array.isArray(manifest.layers) || manifest.layers.length !== 1) {
    throw new Error('Nasiko manifest must contain exactly one OCI layer.');

View on GitHub (pinned to 06c5e118c4)

Solutions

Use a version present in the table, currently 'v0.1.0'
Update the ECC checkout so scripts/lib/nasiko-release.js carries the newest QUALIFIED_RELEASES entries for the version you want
If you maintain the tool, add the new version's per-platform manifestDigest/binaryDigest entries when releasing

Example fix

// before: version not in the qualified table
installNasiko({ version: 'v0.2.0' }); // throws
// after
installNasiko({ version: 'v0.1.0' });

Defensive patterns

Strategy: validation

Validate before calling

// Mirror the qualified matrix the script ships with; update alongside upgrades.
const QUALIFIED = new Set(['v0.1.0']);
const QUALIFIED_PAIRS = new Set([
  'v0.1.0:linux/amd64', 'v0.1.0:linux/arm64',
  'v0.1.0:darwin/amd64', 'v0.1.0:darwin/arm64', 'v0.1.0:windows/amd64',
]);
const os = process.platform === 'win32' ? 'windows' : process.platform;
const arch = process.arch === 'x64' ? 'amd64' : process.arch;
if (!QUALIFIED_PAIRS.has(`${version}:${os}/${arch}`)) version = 'v0.1.0';

Try / catch

try {
  await installNasiko({ version });
} catch (error) {
  if (/is not qualified for/.test(String(error.message))) {
    // Fall back to a known-qualified version (v0.1.0) or update the checkout.
  }
  throw error;
}

Prevention

Keep your pinned version in lockstep with the QUALIFIED_RELEASES table in your ECC revision
After bumping the version constant, grep nasiko-release.js for the new tag's digests
Fail fast in CI on unknown version/platform combinations instead of at install time

When it happens

Trigger: Passing a well-formed version that is absent from the table, e.g. 'v0.2.0' against a checkout that only knows 'v0.1.0'; or a version that exists but has no build for the normalized pair, e.g. 'v0.1.0' on a combination the table omits. Note windows/arm64 is intercepted earlier by the dedicated check in normalizePlatform.

Common situations: A new Nasiko release was tagged upstream but the ECC copy of this script predates it; hardcoding a future version in config; a typo that still matches semver like 'v0.0.1'; forks that add versions to their registry but not to QUALIFIED_RELEASES.

Related errors

AI-assisted analysis of affaan-m/ECC@06c5e118c4 (2026-08-18). Data as JSON: /api/errors/c601db4f830dc042. Report an issue: GitHub.