@aikdna/kdna-cli 0.17.0 → 0.18.0

package/src/loader.js

@@ -15,8 +15,8 @@ const FILE_MAP = core.FILE_MAP;
  * Read and parse a KDNA JSON file.
  * Returns null if the file does not exist.
  */
-function readFile(domainDir, filename) {
-  const filePath = path.join(domainDir, filename);
+function readFile(sourceDir, filename) {
+  const filePath = path.join(sourceDir, filename);
   if (!fs.existsSync(filePath)) return null;
   try {
     return JSON.parse(fs.readFileSync(filePath, 'utf8'));
@@ -29,32 +29,32 @@ function readFile(domainDir, filename) {
  * Load the minimum required KDNA files (Core + Patterns).
  * Always load these. They form the cognition baseline.
  */
-function loadCorePatterns(domainDir) {
-  const coreData = readFile(domainDir, FILE_MAP.core);
-  const patternsData = readFile(domainDir, FILE_MAP.patterns);
+function loadCorePatterns(sourceDir) {
+  const coreData = readFile(sourceDir, FILE_MAP.core);
+  const patternsData = readFile(sourceDir, FILE_MAP.patterns);
   return core.loadCorePatternsFromData(coreData, patternsData);
 }
 
 /**
  * Load a complete KDNA domain.
  *
- * @param {string} domainDir — path to the domain folder
+ * @param {string} sourceDir — path to a dev source directory
  * @param {object} [options]
  * @param {string} [options.input] — user input text for conditional loading
  * @param {'all'|'minimum'|'auto'} [options.mode='auto'] — loading mode
  * @returns {object|null} loaded KDNA files keyed by type, or null if minimum files are missing
  */
-function loadDomain(domainDir, options = {}) {
+function loadDomain(sourceDir, options = {}) {
   const dataMap = { core: null, patterns: null };
 
-  dataMap.core = readFile(domainDir, FILE_MAP.core);
-  dataMap.patterns = readFile(domainDir, FILE_MAP.patterns);
+  dataMap.core = readFile(sourceDir, FILE_MAP.core);
+  dataMap.patterns = readFile(sourceDir, FILE_MAP.patterns);
 
   if (!dataMap.core || !dataMap.patterns) return null;
 
   // Also read optional files that might be present
   for (const key of ['scenarios', 'cases', 'reasoning', 'evolution']) {
-    const data = readFile(domainDir, FILE_MAP[key]);
+    const data = readFile(sourceDir, FILE_MAP[key]);
     if (data) dataMap[key] = data;
   }
 

package/src/package-store.js

@@ -0,0 +1,229 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const PATHS = require('./paths');
+const { parseName } = require('./registry');
+const core = require('@aikdna/kdna-core');
+
+if (typeof core.createKdnaAssetReader !== 'function') {
+  throw new Error('@aikdna/kdna-core >=0.5.0 is required for direct .kdna asset loading');
+}
+
+const assetReader = core.createKdnaAssetReader();
+
+const INDEX_VERSION = 2;
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function readJsonFile(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJsonFile(file, data) {
+  ensureDir(path.dirname(file));
+  fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
+}
+
+function readIndex() {
+  const data = readJsonFile(PATHS.packageIndex);
+  if (data?.packages && typeof data.packages === 'object') return data;
+  return { version: INDEX_VERSION, packages: {} };
+}
+
+function writeIndex(index) {
+  index.version = INDEX_VERSION;
+  writeJsonFile(PATHS.packageIndex, index);
+}
+
+function sha256File(filePath) {
+  return crypto.createHash('sha256').update(fs.readFileSync(filePath)).digest('hex');
+}
+
+function assetDigest(filePath) {
+  return `sha256:${sha256File(filePath)}`;
+}
+
+function contentDigest(kdnaPath) {
+  return assetReader.contentDigestSync(assetReader.openSync(kdnaPath));
+}
+
+function assetDir(scope, ident, version) {
+  return path.join(PATHS.packages, scope, ident, version || 'unknown');
+}
+
+function assetFileName(ident, version) {
+  return `${ident}-${version || 'unknown'}.kdna`;
+}
+
+function readContainerJson(kdnaPath, fileName, options = {}) {
+  const asset = assetReader.openSync(kdnaPath);
+  return assetReader.readJsonSync(asset, fileName, options);
+}
+
+function readContainerEntry(kdnaPath, fileName) {
+  const asset = assetReader.openSync(kdnaPath);
+  return assetReader.readEntrySync(asset, fileName);
+}
+
+function listContainerEntries(kdnaPath) {
+  const asset = assetReader.openSync(kdnaPath);
+  return assetReader.listEntriesSync(asset);
+}
+
+function readContainer(kdnaPath, options = {}) {
+  const asset = assetReader.openSync(kdnaPath);
+  return {
+    manifest: assetReader.readJsonSync(asset, 'kdna.json'),
+    core: assetReader.readJsonSync(asset, 'KDNA_Core.json', options),
+    patterns: assetReader.readJsonSync(asset, 'KDNA_Patterns.json', options),
+    scenarios: assetReader.readJsonSync(asset, 'KDNA_Scenarios.json', options),
+    cases: assetReader.readJsonSync(asset, 'KDNA_Cases.json', options),
+    reasoning: assetReader.readJsonSync(asset, 'KDNA_Reasoning.json', options),
+    evolution: assetReader.readJsonSync(asset, 'KDNA_Evolution.json', options),
+    files: assetReader.listEntriesSync(asset),
+  };
+}
+
+function verifyAsset(kdnaPath, options = {}) {
+  const asset = assetReader.openSync(kdnaPath);
+  return assetReader.verifySync(asset, options);
+}
+
+function getInstalled(input) {
+  const parsed = parseName(input);
+  if (!parsed) return null;
+  const index = readIndex();
+  const entry = index.packages[parsed.full];
+  if (!entry?.asset_path || !fs.existsSync(entry.asset_path)) return null;
+  return { ...entry, parsed };
+}
+
+function listInstalled() {
+  const index = readIndex();
+  return Object.entries(index.packages)
+    .map(([full, entry]) => ({ full, ...entry }))
+    .filter((entry) => entry.asset_path && fs.existsSync(entry.asset_path))
+    .sort((a, b) => a.full.localeCompare(b.full));
+}
+
+function readAssetManifest(assetPath) {
+  return readContainerJson(assetPath, 'kdna.json') || {};
+}
+
+function receiptPathForAsset(assetPath) {
+  return path.join(path.dirname(assetPath), 'receipt.json');
+}
+
+function installAsset({ sourcePath, name, version, source = {} }) {
+  const parsed = parseName(name);
+  if (!parsed) throw new Error(`Invalid scoped domain name: ${name}`);
+  const finalVersion = version || 'unknown';
+  const destDir = assetDir(parsed.scope, parsed.ident, finalVersion);
+  const dest = path.join(destDir, assetFileName(parsed.ident, finalVersion));
+  ensureDir(destDir);
+  fs.copyFileSync(sourcePath, dest);
+
+  const manifest = readAssetManifest(dest);
+  const installedAt = new Date().toISOString();
+  const computedAssetDigest = assetDigest(dest);
+  const computedContentDigest = contentDigest(dest);
+  const receiptPath = receiptPathForAsset(dest);
+  const receipt = {
+    version: 1,
+    name: parsed.full,
+    asset_path: dest,
+    asset_digest: computedAssetDigest,
+    content_digest: computedContentDigest,
+    package_version: finalVersion,
+    judgment_version: manifest.judgment_version || null,
+    access: manifest.access || 'open',
+    signature: manifest.signature || null,
+    installed_at: installedAt,
+    source,
+  };
+  writeJsonFile(receiptPath, receipt);
+
+  const index = readIndex();
+  index.packages[parsed.full] = {
+    name: parsed.full,
+    version: finalVersion,
+    asset_path: dest,
+    receipt_path: receiptPath,
+    asset_digest: computedAssetDigest,
+    content_digest: computedContentDigest,
+    judgment_version: manifest.judgment_version || null,
+    access: manifest.access || 'open',
+    signature: manifest.signature || null,
+    installed_at: installedAt,
+    source,
+  };
+  writeIndex(index);
+  return index.packages[parsed.full];
+}
+
+function resolveAsset(input) {
+  const expanded = input.replace(/^~/, process.env.HOME || '');
+  const looksLikeFile =
+    input.endsWith('.kdna') &&
+    (input.startsWith('./') || input.startsWith('/') || input.startsWith('~/') || fs.existsSync(expanded));
+  if (looksLikeFile) {
+    const abs = path.resolve(expanded);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) return null;
+    const manifest = readAssetManifest(abs);
+    const full = manifest.name;
+    const parsed = full ? parseName(full) : null;
+    return {
+      name: full || path.basename(abs, '.kdna'),
+      parsed,
+      asset_path: abs,
+      receipt_path: null,
+      version: manifest.version || null,
+      judgment_version: manifest.judgment_version || null,
+      access: manifest.access || 'open',
+      asset_digest: assetDigest(abs),
+      content_digest: contentDigest(abs),
+      source: { type: 'local-file', path: abs },
+      local_file: true,
+    };
+  }
+  return getInstalled(input);
+}
+
+function removeInstalled(input) {
+  const parsed = parseName(input);
+  if (!parsed) return false;
+  const index = readIndex();
+  const entry = index.packages[parsed.full];
+  if (!entry) return false;
+  delete index.packages[parsed.full];
+  writeIndex(index);
+  if (entry.asset_path) {
+    const versionDir = path.dirname(entry.asset_path);
+    fs.rmSync(versionDir, { recursive: true, force: true });
+  }
+  return true;
+}
+
+module.exports = {
+  readIndex,
+  writeIndex,
+  sha256File,
+  assetDigest,
+  contentDigest,
+  readContainer,
+  readContainerEntry,
+  readContainerJson,
+  listContainerEntries,
+  verifyAsset,
+  getInstalled,
+  listInstalled,
+  installAsset,
+  resolveAsset,
+  removeInstalled,
+};

package/src/paths.js

@@ -0,0 +1,44 @@
+// KDNA shared path configuration — canonical source for ~/.kdna structure
+// Spec: docs/local-kdna-home-spec.md
+
+const path = require('path');
+
+const KDNA_HOME = process.env.KDNA_HOME
+  || path.join(process.env.HOME || process.env.USERPROFILE || '.', '.kdna');
+
+const PATHS = {
+  root: KDNA_HOME,
+  config: path.join(KDNA_HOME, 'config.json'),
+  identity: path.join(KDNA_HOME, 'identity'),
+  domains: {
+    root: path.join(KDNA_HOME, 'domains'),
+    official: path.join(KDNA_HOME, 'domains', 'official'),
+    local: path.join(KDNA_HOME, 'domains', 'local'),
+    private: path.join(KDNA_HOME, 'domains', 'private'),
+    // Legacy flat path — used for migration only
+    legacy: path.join(KDNA_HOME, 'domains'),
+    // All three directories for scanning
+    all: [
+      path.join(KDNA_HOME, 'domains', 'official'),
+      path.join(KDNA_HOME, 'domains', 'local'),
+      path.join(KDNA_HOME, 'domains', 'private'),
+    ],
+  },
+  clusters: path.join(KDNA_HOME, 'clusters'),
+  packages: path.join(KDNA_HOME, 'packages'),
+  packageIndex: path.join(KDNA_HOME, 'index.json'),
+  registry: path.join(KDNA_HOME, 'registry'),
+  registryCache: path.join(KDNA_HOME, 'registry', 'cache.json'),
+  traces: path.join(KDNA_HOME, 'traces'),
+  feedback: path.join(KDNA_HOME, 'feedback'),
+  evals: path.join(KDNA_HOME, 'evals'),
+  cache: path.join(KDNA_HOME, 'cache'),
+  licenses: path.join(KDNA_HOME, 'licenses'),
+};
+
+// Runtime asset store aliases
+PATHS.USER_KDNA_DIR = KDNA_HOME;
+PATHS.INSTALL_DIR = PATHS.packages;
+
+module.exports = PATHS;
+module.exports.KDNA_HOME = KDNA_HOME;

package/src/publish.js

@@ -7,7 +7,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { EXIT } = require('./cmds/_common');
+const { EXIT, selfCheckText, isYesNoSelfCheck } = require('./cmds/_common');
 
 function error(msg, code = EXIT.VALIDATION_FAILED) {
   console.error(`Error: ${msg}`);
@@ -143,8 +143,6 @@ function isGenericSelfCheck(question) {
 
 // ─── Human Lock Gate ──────────────────────────────────────────────────
 
-const JUDGMENT_CARD_TYPES = ['axiom', 'boundary', 'risk', 'aesthetic'];
-
 /**
  * Check whether the domain satisfies Human Lock requirements.
  * Returns { passed, issues[] } — publish should be blocked if !passed.
@@ -384,21 +382,22 @@ function cmdPublishCheck(domainPath, args = []) {
     }
     for (let i = 0; i < core.stances.length; i++) {
       const s = core.stances[i];
-      if (typeof s !== 'string') {
+      const stanceText = typeof s === 'string' ? s : s && typeof s === 'object' ? s.stance : null;
+      if (!stanceText || typeof stanceText !== 'string') {
         fail(
           'KDNA_Core.json',
           `stances[${i}]`,
           JSON.stringify(s),
-          'Must be a string, not an object.',
+          'Must be a string or an object with a stance string.',
         );
-      } else if (isSlogan(s)) {
+      } else if (isSlogan(stanceText)) {
         fail(
           'KDNA_Core.json',
           `stances[${i}]`,
-          s,
+          stanceText,
           'Reads like a slogan. Stances must be prescriptive positions that bias agent behavior.',
         );
-      } else if (isVague(s)) {
+      } else if (isVague(stanceText)) {
         warn('KDNA_Core.json', `stances[${i}]`, 'Contains vague language.');
       } else {
         pass('KDNA_Core.json', `stances[${i}]`);
@@ -442,22 +441,23 @@ function cmdPublishCheck(domainPath, args = []) {
   if (patterns.self_check && Array.isArray(patterns.self_check)) {
     for (let i = 0; i < patterns.self_check.length; i++) {
       const sc = patterns.self_check[i];
-      if (typeof sc !== 'string') {
+      const text = selfCheckText(sc);
+      if (!text) {
         fail(
           'KDNA_Patterns.json',
           `self_check[${i}]`,
           JSON.stringify(sc),
-          'Must be a string, not an object.',
+          'Must be a string or an object with a question string.',
         );
-      } else if (isGenericSelfCheck(sc)) {
+      } else if (isGenericSelfCheck(text)) {
         fail(
           'KDNA_Patterns.json',
           `self_check[${i}]`,
-          sc,
+          text,
           'Generic question. Self-checks must be domain-specific, not "is this helpful?".',
         );
-      } else if (!sc.endsWith('?')) {
-        warn('KDNA_Patterns.json', `self_check[${i}]`, 'Should end with a question mark.');
+      } else if (!isYesNoSelfCheck(sc)) {
+        warn('KDNA_Patterns.json', `self_check[${i}]`, 'Should be answerable with yes/no.');
         passes++;
       } else {
         pass('KDNA_Patterns.json', `self_check[${i}]`);
@@ -531,9 +531,9 @@ function identityPaths() {
  * inside the .kdna ZIP, joined as `name:hex\n`. This is what the signature covers.
  *
  * Excludes the `signature` field from kdna.json itself (computed by removing it
- * before hashing). All other files included as-is.
+ * before hashing). Digest self-reference fields are also excluded. All other files included as-is.
  */
-function canonicalPayload(srcDir) {
+function canonicalPayload(srcDir, opts = {}) {
   const files = fs
     .readdirSync(srcDir)
     .filter((f) => f.endsWith('.json'))
@@ -545,6 +545,10 @@ function canonicalPayload(srcDir) {
     if (f === 'kdna.json') {
       const obj = JSON.parse(fs.readFileSync(full, 'utf8'));
       delete obj.signature;
+      delete obj.asset_digest;
+      delete obj.container_sha256;
+      if (!opts.includeContentDigest) delete obj.content_digest;
+      delete obj._source;
       buf = Buffer.from(JSON.stringify(obj));
     } else {
       buf = fs.readFileSync(full);
@@ -555,6 +559,46 @@ function canonicalPayload(srcDir) {
   return parts.join('\n');
 }
 
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function manifestForContentDigest(manifest) {
+  const copy = { ...(manifest || {}) };
+  delete copy.signature;
+  delete copy.asset_digest;
+  delete copy.container_sha256;
+  delete copy.content_digest;
+  delete copy._source;
+  return copy;
+}
+
+function sourceContentDigest(srcDir) {
+  const files = fs
+    .readdirSync(srcDir)
+    .filter((f) => f.endsWith('.json') || f === 'README.md' || f === 'LICENSE')
+    .sort();
+  const parts = [];
+  for (const f of files) {
+    let buf;
+    if (f === 'kdna.json') {
+      const obj = JSON.parse(fs.readFileSync(path.join(srcDir, f), 'utf8'));
+      buf = Buffer.from(stableStringify(manifestForContentDigest(obj)));
+    } else {
+      buf = fs.readFileSync(path.join(srcDir, f));
+    }
+    parts.push(`${f}:${crypto.createHash('sha256').update(buf).digest('hex')}`);
+  }
+  return `sha256:${crypto.createHash('sha256').update(Buffer.from(parts.join('\n'))).digest('hex')}`;
+}
+
 function signPayload(payload, privateKeyPem) {
   const privateKey = crypto.createPrivateKey(privateKeyPem);
   const sig = crypto.sign(null, Buffer.from(payload), privateKey);
@@ -582,7 +626,7 @@ function packToFile(domainDir, outPath) {
   const files = fs
     .readdirSync(domainDir)
     .filter((f) => f.endsWith('.json') || f === 'README.md' || f === 'LICENSE');
-  if (!files.includes('kdna.json')) error('kdna.json required in domain folder for publish.');
+  if (!files.includes('kdna.json')) error('kdna.json required in dev source directory for publish.');
 
   const script = `import zipfile, os
 src = ${JSON.stringify(domainDir)}
@@ -679,9 +723,14 @@ function cmdPublish(domainPath, args = []) {
 
   // 2. Write signature
   delete manifest.signature;
+  delete manifest.asset_digest;
+  delete manifest.container_sha256;
+  delete manifest.content_digest;
+  fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+  manifest.content_digest = sourceContentDigest(abs);
   fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
-  const payload = canonicalPayload(abs);
-  const sig = signPayload(payload, privateKey);
+  const signedPayload = canonicalPayload(abs, { includeContentDigest: true });
+  const sig = signPayload(signedPayload, privateKey);
   manifest.signature = 'ed25519:' + sig;
   fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
   console.log(
@@ -697,9 +746,10 @@ function cmdPublish(domainPath, args = []) {
   const outPath = path.join(outDir, fileName);
   packToFile(abs, outPath);
   const sha256 = sha256File(outPath);
+  const assetDigest = `sha256:${sha256}`;
   const size = fs.statSync(outPath).size;
   console.log(`  ✓ Packed: ${outPath} (${size} bytes)`);
-  console.log(`  ✓ sha256: ${sha256}`);
+  console.log(`  ✓ asset_digest: ${assetDigest}`);
 
   // 4. Optional upload via gh CLI
   const tagIdx = args.indexOf('--release-tag');
@@ -726,8 +776,9 @@ function cmdPublish(domainPath, args = []) {
     name,
     type: manifest.cluster ? 'cluster' : 'domain',
     version: manifest.version,
-    kdna_url: kdnaUrl,
-    sha256,
+    asset_url: kdnaUrl,
+    asset_digest: assetDigest,
+    content_digest: manifest.content_digest || null,
     signature: manifest.signature,
     release_status: kdnaUrl ? 'published_signed' : 'published_signed_local',
     author: { ...manifest.author },

package/src/registry.js

@@ -1,5 +1,5 @@
 /**
- * RegistryResolver — KDNA v0.7 registry client.
+ * RegistryResolver — KDNA asset-first registry client.
  *
  * Responsibilities:
  *   1. Resolve names: bare → @aikdna/bare, validate @scope/name format
@@ -7,7 +7,7 @@
  *   3. Cache registry metadata locally
  *   4. Surface scope trust info to install/publish
  *
- * Schema v2.0 — see kdna-registry/SCHEMA.md
+ * Schema v3.0 — see kdna-registry/SCHEMA.md
  */
 
 const fs = require('fs');
@@ -22,6 +22,7 @@ const DEFAULT_OFFICIAL_SCOPE = '@aikdna';
 const CANONICAL_REGISTRY_URL =
   process.env.KDNA_REGISTRY_URL ||
   'https://raw.githubusercontent.com/aikdna/kdna-registry/main/domains.json';
+const REQUIRED_SCHEMA_VERSION = '3.0';
 
 const NAME_RE = /^@([a-z][a-z0-9-]*)\/([a-z][a-z0-9_]*)$/;
 const BARE_NAME_RE = /^[a-z][a-z0-9_]*$/;
@@ -39,6 +40,60 @@ function writeJson(file, data) {
   fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n');
 }
 
+function parseDate(value) {
+  const date = value ? new Date(value) : null;
+  return date && !Number.isNaN(date.getTime()) ? date : null;
+}
+
+function registryTrustIssues(registry, { now = new Date() } = {}) {
+  const issues = [];
+  const trust = registry?.trust || {};
+
+  if (!registry || registry.schema_version !== REQUIRED_SCHEMA_VERSION) {
+    issues.push(
+      `Registry schema_version must be ${REQUIRED_SCHEMA_VERSION}, got ${JSON.stringify(registry?.schema_version)}`,
+    );
+  }
+
+  if (!trust.model) issues.push('registry.trust.model is required');
+  if (!trust.snapshot) issues.push('registry.trust.snapshot is required');
+  if (!trust.timestamp) issues.push('registry.trust.timestamp is required');
+
+  const snapshotVersion = trust.snapshot?.registry_version;
+  if (snapshotVersion && snapshotVersion !== registry.registry_version) {
+    issues.push(
+      `registry.trust.snapshot.registry_version ${snapshotVersion} does not match registry_version ${registry.registry_version}`,
+    );
+  }
+
+  const snapshotExpires = parseDate(trust.snapshot?.expires_at);
+  const timestampExpires = parseDate(trust.timestamp?.expires_at);
+  if (!snapshotExpires) issues.push('registry.trust.snapshot.expires_at must be an ISO timestamp');
+  if (!timestampExpires) issues.push('registry.trust.timestamp.expires_at must be an ISO timestamp');
+  if (snapshotExpires && snapshotExpires <= now) {
+    issues.push(`registry snapshot expired at ${trust.snapshot.expires_at}`);
+  }
+  if (timestampExpires && timestampExpires <= now) {
+    issues.push(`registry timestamp expired at ${trust.timestamp.expires_at}`);
+  }
+
+  return issues;
+}
+
+function registryRevocations(registry) {
+  return registry?.trust?.revocations || [];
+}
+
+function isEntryRevoked(registry, entry) {
+  const revocations = registryRevocations(registry);
+  return revocations.find((rev) => {
+    if (rev.name && rev.name !== entry.name) return false;
+    if (rev.version && rev.version !== entry.version) return false;
+    if (rev.asset_digest && rev.asset_digest !== entry.asset_digest) return false;
+    return rev.name || rev.asset_digest;
+  }) || null;
+}
+
 // ─── Name parsing ───────────────────────────────────────────────────────
 
 /**
@@ -151,7 +206,15 @@ class RegistryResolver {
   _loadRegistryForScope(scopeName) {
     if (this._registries.has(scopeName)) return this._registries.get(scopeName);
     const source = this._sourceForScope(scopeName);
-    const data = source.load({ allowNetwork: this.allowNetwork, refresh: this.refresh });
+    let data = source.load({ allowNetwork: this.allowNetwork, refresh: this.refresh });
+    let trustIssues = data ? registryTrustIssues(data) : [];
+    if (trustIssues.length && this.allowNetwork && !this.refresh) {
+      data = source.load({ allowNetwork: true, refresh: true });
+      trustIssues = data ? registryTrustIssues(data) : [];
+    }
+    if (trustIssues.length) {
+      throw new Error(`Registry trust check failed:\n${trustIssues.map((i) => `- ${i}`).join('\n')}`);
+    }
     this._registries.set(scopeName, data);
     return data;
   }
@@ -186,12 +249,6 @@ class RegistryResolver {
       );
     }
 
-    if (registry.schema_version && registry.schema_version !== '2.0') {
-      throw new Error(
-        `Registry schema_version ${registry.schema_version} not supported. This CLI requires 2.0.`,
-      );
-    }
-
     const scope = registry.scopes?.[parsed.scope];
     if (!scope) {
       throw new Error(`Scope ${parsed.scope} not registered in registry.`);
@@ -215,6 +272,13 @@ class RegistryResolver {
       throw new Error(`${entry.name}@${entry.version} has been yanked${when}.${reason}${replace}`);
     }
 
+    const revocation = isEntryRevoked(registry, entry);
+    if (revocation) {
+      const reason = revocation.reason ? `\nReason: ${revocation.reason}` : '';
+      const when = revocation.revoked_at ? ` (revoked ${revocation.revoked_at.slice(0, 10)})` : '';
+      throw new Error(`${entry.name}@${entry.version} has been revoked${when}.${reason}`);
+    }
+
     return { parsed, scope, entry, registry };
   }
 
@@ -250,6 +314,9 @@ function fetchRegistry() {
 module.exports = {
   RegistryResolver,
   parseName,
+  REQUIRED_SCHEMA_VERSION,
+  registryTrustIssues,
+  isEntryRevoked,
   loadRegistry,
   fetchRegistry,
   CANONICAL_REGISTRY_URL,