@aikdna/kdna-core 0.17.0 → 0.19.0

package/src/container/index.mjs

@@ -0,0 +1,20 @@
+import containerApi from './index.js';
+
+export const MIMETYPE = containerApi.MIMETYPE;
+export const REQUIRED_DIR_ENTRIES = containerApi.REQUIRED_DIR_ENTRIES;
+export const isKdnaSourceDir = containerApi.isKdnaSourceDir;
+export const detectContainerFormat = containerApi.detectContainerFormat;
+export const readLayout = containerApi.readLayout;
+export const inspect = containerApi.inspect;
+export const validate = containerApi.validate;
+export const planLoad = containerApi.planLoad;
+export const loadAuthorized = containerApi.loadAuthorized;
+export const buildChecksums = containerApi.buildChecksums;
+export const computeRuntimeEntrySetDigest = containerApi.computeRuntimeEntrySetDigest;
+export const pack = containerApi.pack;
+export const unpack = containerApi.unpack;
+export const load = containerApi.load;
+export const loadAsset = containerApi.loadAsset;
+export const FORBIDDEN_OUTPUT_TERMS = containerApi.FORBIDDEN_OUTPUT_TERMS;
+
+export default containerApi;

package/src/container-dispatcher.js

@@ -18,7 +18,8 @@ const MIMETYPE = 'application/vnd.kdna.asset';
  * @property {object}       manifest         — parsed kdna.json
  * @property {Buffer}       payloadRaw       — raw payload.kdnab bytes
  * @property {object|null}  checksums
- * @property {Buffer|null}  assetDigest
+ * @property {Buffer|null}  assetDigest      — legacy internal name for final container bytes
+ * @property {string|null}  containerDigest  — tagged SHA-256 of final container bytes
  * @property {Buffer|null}  containerBuffer
  * @property {Map<string, Buffer>|null} entries
  */
@@ -177,13 +178,14 @@ function readSourceDirectory(absPath, _opts) {
     payloadRaw,
     checksums,
     assetDigest: null,
+    containerDigest: null,
     containerBuffer: null,
     entries,
   };
 }
 
 function readKdnaContainer(absPath, _opts) {
-  const v1Layout = require('./v1/index.js').readLayout(absPath);
+  const layout = require('./container/index.js').readLayout(absPath);
   const containerBuf = fs.readFileSync(absPath);
   const assetDigest = crypto.createHash('sha256').update(containerBuf).digest();
 
@@ -192,14 +194,15 @@ function readKdnaContainer(absPath, _opts) {
     sourcePath: absPath,
     format: 'kdna',
     mimetype: MIMETYPE,
-    manifest: v1Layout.manifest,
-    payloadRaw: v1Layout.map['payload.kdnab'] || null,
-    checksums: v1Layout.map['checksums.json']
-      ? (() => { try { return JSON.parse(v1Layout.map['checksums.json'].toString('utf8')); } catch { return null; } })()
+    manifest: layout.manifest,
+    payloadRaw: layout.map['payload.kdnab'] || null,
+    checksums: layout.map['checksums.json']
+      ? (() => { try { return JSON.parse(layout.map['checksums.json'].toString('utf8')); } catch { return null; } })()
       : null,
     assetDigest,
+    containerDigest: `sha256:${assetDigest.toString('hex')}`,
     containerBuffer: containerBuf,
-    entries: new Map(Object.entries(v1Layout.map)),
+    entries: new Map(Object.entries(layout.map)),
   };
 }
 

package/src/crypto-profile.js

@@ -17,14 +17,7 @@ try {
  * - AES-256-GCM content encryption
  * - Random CEK per asset; license key only unwraps CEK, never touches content
  */
-const LICENSED_ENTRY_PROFILE = 'kdna-licensed-entry-v1';
-
-/**
- * Pre-RFC legacy profile (now experimental).
- * Uses scrypt-sha256 with concatenated secret (`licenseKey|machineFingerprint`).
- * Retained for backward compatibility only.
- */
-const LICENSED_EXPERIMENTAL_PROFILE = 'kdna-licensed-entry-experimental';
+const LICENSED_ENTRY_PROFILE = 'kdna.encryption.licensed-entry';
 
 /**
  * RFC-0009 compliant profile.
@@ -33,11 +26,11 @@ const LICENSED_EXPERIMENTAL_PROFILE = 'kdna-licensed-entry-experimental';
  * - AES-256-GCM content encryption
  * - Dual key slots: password + recovery
  */
-const PASSWORD_PROTECTED_PROFILE = 'kdna-password-protected-v1';
+const PASSWORD_PROTECTED_PROFILE = 'kdna.encryption.password';
+const ENCRYPTION_PROFILE_VERSION = '0.1.0';
 
 const RFC_KDF = 'HKDF-SHA256';
 const RFC_KEY_WRAPPING = 'AES-256-KW';
-const LEGACY_KDF = 'scrypt-sha256';
 const PASSWORD_KDF = 'Argon2id';
 const ALG = 'AES-256-GCM';
 
@@ -63,14 +56,20 @@ function normalizeEnvelope(value) {
     try { return cbor.decode(Buffer.from(value, 'utf8')); } catch { /* fall through */ }
   }
   if (value && typeof value === 'object') return value;
-  throw new Error('encrypted entry envelope must be CBOR (kdna_version 1.0)');
+  throw new Error('encrypted entry envelope must be CBOR (format 0.1.0)');
 }
 
-function encryptedEntryAad(entryName, manifest = {}, profile = LICENSED_ENTRY_PROFILE) {
+function encryptedEntryAad(
+  entryName,
+  manifest = {},
+  profile = LICENSED_ENTRY_PROFILE,
+  profileVersion = ENCRYPTION_PROFILE_VERSION,
+) {
   return Buffer.from(
     [
       profile,
-      manifest.name || manifest.asset_id || '',
+      profileVersion,
+      manifest.asset_id || '',
       manifest.version || '',
       entryName,
     ].join('\n'),
@@ -173,7 +172,7 @@ function aesUnwrap(key, ciphertext) {
 /**
  * Derive a key-wrapping key (KWK) from a license key via HKDF-SHA256.
  */
-function deriveWrappingKey(licenseKey, info = 'kdna-licensed-entry-v1-kwk') {
+function deriveWrappingKey(licenseKey, info = 'kdna.encryption.licensed-entry-kwk') {
   return hkdfSha256(licenseKey, null, info, 32);
 }
 
@@ -207,7 +206,7 @@ function unwrapCEK(wrappedCek, wrappingKey) {
  * 4. Wrap CEK with KWK (AES-256-KW)
  * 5. Store wrapped_key in envelope
  */
-function encryptLicensedEntryV1(plaintext, options = {}) {
+function encryptLicensedEntry(plaintext, options = {}) {
   const { entryName, manifest = {}, licenseKey } = options;
   if (!entryName) throw new Error('entryName is required');
   if (!licenseKey) throw new Error('licenseKey is required for RFC-0008 encryption');
@@ -223,6 +222,7 @@ function encryptLicensedEntryV1(plaintext, options = {}) {
 
   return {
     profile: LICENSED_ENTRY_PROFILE,
+    profile_version: ENCRYPTION_PROFILE_VERSION,
     alg: ALG,
     kdf: RFC_KDF,
     key_wrapping: RFC_KEY_WRAPPING,
@@ -240,7 +240,7 @@ function encryptLicensedEntryV1(plaintext, options = {}) {
  * 2. Unwrap CEK from wrapped_key (AES-256-KW)
  * 3. Decrypt content with CEK (AES-256-GCM)
  */
-function decryptLicensedEntryV1(envelopeValue, options = {}) {
+function decryptLicensedEntry(envelopeValue, options = {}) {
   const { entryName, manifest = {}, licenseKey } = options;
   if (!entryName) throw new Error('entryName is required');
   if (!licenseKey) throw new Error('licenseKey is required for RFC-0008 decryption');
@@ -249,6 +249,9 @@ function decryptLicensedEntryV1(envelopeValue, options = {}) {
   if (envelope.profile !== LICENSED_ENTRY_PROFILE) {
     throw new Error(`unsupported encrypted entry profile: ${envelope.profile || 'unknown'} (expected ${LICENSED_ENTRY_PROFILE})`);
   }
+  if (envelope.profile_version !== ENCRYPTION_PROFILE_VERSION) {
+    throw new Error(`unsupported encrypted entry profile_version: ${envelope.profile_version || 'unknown'}`);
+  }
   if (envelope.alg !== ALG) throw new Error(`unsupported encrypted entry alg: ${envelope.alg}`);
   if (envelope.kdf !== RFC_KDF) throw new Error(`unsupported encrypted entry kdf: ${envelope.kdf}`);
   if (envelope.key_wrapping !== RFC_KEY_WRAPPING) throw new Error(`unsupported encrypted entry key_wrapping: ${envelope.key_wrapping}`);
@@ -358,6 +361,7 @@ function encryptProtectedEntry(plaintext, options = {}) {
 
   return {
     profile: PASSWORD_PROTECTED_PROFILE,
+    profile_version: ENCRYPTION_PROFILE_VERSION,
     alg: ALG,
     kdf: PASSWORD_KDF,
     key_wrapping: RFC_KEY_WRAPPING,
@@ -382,6 +386,9 @@ function decryptProtectedEntry(envelopeValue, options = {}) {
       `unsupported encrypted entry profile: ${envelope.profile || 'unknown'} (expected ${PASSWORD_PROTECTED_PROFILE})`,
     );
   }
+  if (envelope.profile_version !== ENCRYPTION_PROFILE_VERSION) {
+    throw new Error(`unsupported encrypted entry profile_version: ${envelope.profile_version || 'unknown'}`);
+  }
   if (envelope.alg !== ALG) throw new Error(`unsupported encrypted entry alg: ${envelope.alg}`);
   if (envelope.kdf !== PASSWORD_KDF) throw new Error(`unsupported encrypted entry kdf: ${envelope.kdf}`);
   if (envelope.key_wrapping !== RFC_KEY_WRAPPING) {
@@ -422,12 +429,12 @@ function createRecoveryDecryptEntry(options = {}) {
     decryptProtectedEntry(ciphertext, { entryName, manifest, recoveryCode });
 }
 
-// ── B2: scrypt-based password profile (v0.1 write profile) ─────────
+// ── B2: scrypt-based password profile (0.1 write profile) ─────────
 // Uses Node built-in crypto.scryptSync — zero additional dependencies.
-// v0.2 will promote the Argon2id profile (above) as the default write
+// 0.2 will promote the Argon2id profile (above) as the default write
 // profile; this scrypt profile will remain a read-only legacy profile.
 
-const PASSWORD_PROTECTED_SCRYPT_PROFILE = 'kdna-password-protected-v1-scrypt';
+const PASSWORD_PROTECTED_SCRYPT_PROFILE = 'kdna.encryption.password.scrypt';
 const SCRYPT_KDF = 'scrypt-sha256';
 
 function derivePasswordKeyScrypt(password, params = {}) {
@@ -468,6 +475,7 @@ function encryptProtectedEntryScrypt(plaintext, options = {}) {
 
   return {
     profile: PASSWORD_PROTECTED_SCRYPT_PROFILE,
+    profile_version: ENCRYPTION_PROFILE_VERSION,
     alg: ALG,
     kdf: SCRYPT_KDF,
     key_wrapping: RFC_KEY_WRAPPING,
@@ -508,6 +516,9 @@ function decryptProtectedEntryScrypt(envelopeValue, options = {}) {
       `unsupported encrypted entry profile: ${envelope.profile || 'unknown'} (expected ${PASSWORD_PROTECTED_SCRYPT_PROFILE})`,
     );
   }
+  if (envelope.profile_version !== ENCRYPTION_PROFILE_VERSION) {
+    throw new Error(`unsupported encrypted entry profile_version: ${envelope.profile_version || 'unknown'}`);
+  }
   if (envelope.alg !== ALG) throw new Error(`unsupported encrypted entry alg: ${envelope.alg}`);
   if (envelope.kdf !== SCRYPT_KDF) throw new Error(`unsupported encrypted entry kdf: ${envelope.kdf}`);
   if (envelope.key_wrapping !== RFC_KEY_WRAPPING) {
@@ -537,95 +548,21 @@ function createPasswordDecryptEntryScrypt(options = {}) {
     decryptProtectedEntryScrypt(ciphertext, { entryName, manifest, password });
 }
 
-// ── Legacy / experimental profile (pre-RFC, backward compat) ───────
-
-function deriveLicensedEntryKeyLegacy(options = {}) {
-  const { licenseKey, machineFingerprint, salt, keyLength = 32 } = options;
-  if (!licenseKey) throw new Error('licenseKey is required');
-  if (!machineFingerprint) throw new Error('machineFingerprint is required');
-  const saltBuffer = Buffer.isBuffer(salt) || salt instanceof Uint8Array
-    ? Buffer.from(salt)
-    : decodeBase64(salt, 'salt');
-  const secret = `${licenseKey}|${machineFingerprint}`;
-  return crypto.scryptSync(secret, saltBuffer, keyLength);
-}
-
-function encryptLicensedEntryLegacy(plaintext, options = {}) {
-  const { entryName, manifest = {}, licenseKey, machineFingerprint } = options;
-  if (!entryName) throw new Error('entryName is required');
-  const salt = crypto.randomBytes(16);
-  const iv = crypto.randomBytes(12);
-  const key = deriveLicensedEntryKeyLegacy({ licenseKey, machineFingerprint, salt });
-  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
-  cipher.setAAD(encryptedEntryAad(entryName, manifest, LICENSED_EXPERIMENTAL_PROFILE));
-  const ciphertext = Buffer.concat([cipher.update(toBuffer(plaintext, 'plaintext')), cipher.final()]);
-  return {
-    profile: LICENSED_EXPERIMENTAL_PROFILE,
-    alg: ALG,
-    kdf: LEGACY_KDF,
-    salt: salt.toString('base64'),
-    iv: iv.toString('base64'),
-    tag: cipher.getAuthTag().toString('base64'),
-    ciphertext: ciphertext.toString('base64'),
-  };
-}
-
-function decryptLicensedEntryLegacy(envelopeValue, options = {}) {
-  const { entryName, manifest = {}, licenseKey, machineFingerprint } = options;
-  if (!entryName) throw new Error('entryName is required');
-  const envelope = normalizeEnvelope(envelopeValue);
-  if (envelope.profile !== LICENSED_EXPERIMENTAL_PROFILE) {
-    throw new Error(`unsupported encrypted entry profile: ${envelope.profile || 'unknown'}`);
-  }
-  if (envelope.alg !== ALG) throw new Error(`unsupported encrypted entry alg: ${envelope.alg}`);
-  if (envelope.kdf !== LEGACY_KDF) throw new Error(`unsupported encrypted entry kdf: ${envelope.kdf}`);
-  const key = deriveLicensedEntryKeyLegacy({
-    licenseKey,
-    machineFingerprint,
-    salt: envelope.salt,
-  });
-  const decipher = crypto.createDecipheriv('aes-256-gcm', key, decodeBase64(envelope.iv, 'iv'));
-  decipher.setAAD(encryptedEntryAad(entryName, manifest, LICENSED_EXPERIMENTAL_PROFILE));
-  decipher.setAuthTag(decodeBase64(envelope.tag, 'tag'));
-  return Buffer.concat([
-    decipher.update(decodeBase64(envelope.ciphertext, 'ciphertext')),
-    decipher.final(),
-  ]);
-}
-
-// ── Unified entry points (auto-detect profile) ────────────────────
-
-function encryptLicensedEntry(plaintext, options = {}) {
-  return encryptLicensedEntryV1(plaintext, options);
-}
-
-function decryptLicensedEntry(envelopeValue, options = {}) {
-  const envelope = normalizeEnvelope(envelopeValue);
-  if (envelope.profile === LICENSED_ENTRY_PROFILE) {
-    return decryptLicensedEntryV1(envelopeValue, options);
-  }
-  if (envelope.profile === LICENSED_EXPERIMENTAL_PROFILE) {
-    return decryptLicensedEntryLegacy(envelopeValue, options);
-  }
-  throw new Error(`unsupported encrypted entry profile: ${envelope.profile || 'unknown'}`);
-}
-
 function createLicensedDecryptEntry(options = {}) {
-  const { licenseKey, machineFingerprint } = options;
+  const { licenseKey } = options;
   return ({ entryName, ciphertext, manifest }) =>
-    decryptLicensedEntry(ciphertext, { entryName, manifest, licenseKey, machineFingerprint });
+    decryptLicensedEntry(ciphertext, { entryName, manifest, licenseKey });
 }
 
 module.exports = {
   // Profiles
   LICENSED_ENTRY_PROFILE,
-  LICENSED_EXPERIMENTAL_PROFILE,
   PASSWORD_PROTECTED_PROFILE,
   PASSWORD_PROTECTED_SCRYPT_PROFILE,
+  ENCRYPTION_PROFILE_VERSION,
   ALG,
   RFC_KDF,
   RFC_KEY_WRAPPING,
-  LEGACY_KDF,
   PASSWORD_KDF,
   SCRYPT_KDF,
 
@@ -634,8 +571,8 @@ module.exports = {
   generateCEK,
   wrapCEK,
   unwrapCEK,
-  encryptLicensedEntryV1,
-  decryptLicensedEntryV1,
+  encryptLicensedEntry,
+  decryptLicensedEntry,
 
   // RFC-0009 compliant (Argon2id)
   derivePasswordKey,
@@ -646,20 +583,13 @@ module.exports = {
   createPasswordDecryptEntry,
   createRecoveryDecryptEntry,
 
-  // B2 scrypt password profile (v0.1 write profile)
+  // B2 scrypt password profile (0.1 write profile)
   derivePasswordKeyScrypt,
   encryptProtectedEntryScrypt,
   decryptProtectedEntryScrypt,
   createPasswordDecryptEntryScrypt,
 
-  // Legacy
-  deriveLicensedEntryKey: deriveLicensedEntryKeyLegacy,
-  encryptLicensedEntryLegacy,
-  decryptLicensedEntryLegacy,
-
-  // Unified
-  encryptLicensedEntry,
-  decryptLicensedEntry,
+  // Consumer adapter
   createLicensedDecryptEntry,
 
   // Low-level

package/src/external-key-grant.js

@@ -8,26 +8,27 @@
 
 const crypto = require('node:crypto');
 const path = require('node:path');
-const Ajv2020 = require('ajv/dist/2020');
+const JsonSchema2020 = require('ajv/dist/2020');
 const addFormats = require('ajv-formats');
 const cbor = require('cbor-x');
 const { hkdfSha256, aesWrap, aesUnwrap } = require('./crypto-profile');
 
-const EXTERNAL_ENVELOPE_PROFILE = 'kdna-envelope-external-grant-v1';
-const EXTERNAL_GRANT_PROFILE = 'kdna-key-grant-v1';
-const EXTERNAL_AAD_PROFILE = 'kdna-external-asset-cek-v1';
-const DEVICE_KEK_PROFILE = 'kdna-device-grant-kek-v1';
+const EXTERNAL_ENVELOPE_PROFILE = 'kdna.envelope.external-grant';
+const EXTERNAL_GRANT_PROFILE = 'kdna.grant.external-key';
+const EXTERNAL_AAD_PROFILE = 'kdna.key-context.asset-content';
+const DEVICE_KEK_PROFILE = 'kdna.key-context.device-grant';
+const EXTERNAL_GRANT_CONTRACT_VERSION = '0.1.0';
 const ENVELOPE_ALG = 'A256GCM';
 const GRANT_WRAP_ALG = 'X25519-HKDF-SHA256+A256KW';
 
 const schemaRoot = path.join(__dirname, '..', 'schema');
-const ajv = new Ajv2020({ allErrors: true, strict: true });
+const ajv = new JsonSchema2020({ allErrors: true, strict: true });
 addFormats(ajv);
 const validateEnvelopeSchema = ajv.compile(
-  require(path.join(schemaRoot, 'kdna-envelope-external-grant-v1.schema.json')),
+  require(path.join(schemaRoot, 'external-grant-envelope.schema.json')),
 );
 const validateGrantSchema = ajv.compile(
-  require(path.join(schemaRoot, 'kdna-key-grant-v1.schema.json')),
+  require(path.join(schemaRoot, 'external-key-grant.schema.json')),
 );
 
 const verifiedEntitlements = new WeakSet();
@@ -127,8 +128,9 @@ function externalEnvelopeAad({ manifest, entryName, plaintextDigest, keyRef, iss
   const entitlementProfile = manifest?.entitlement?.profile || '';
   const fields = [
     EXTERNAL_ENVELOPE_PROFILE,
+    EXTERNAL_GRANT_CONTRACT_VERSION,
     manifest?.asset_uid || '',
-    manifest?.asset_id || manifest?.name || '',
+    manifest?.asset_id || '',
     manifest?.version || '',
     entryName,
     plaintextDigest,
@@ -210,6 +212,7 @@ function encryptExternalGrantEntry(plaintextValue, options = {}) {
     const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
     return {
       profile: EXTERNAL_ENVELOPE_PROFILE,
+      contract_version: EXTERNAL_GRANT_CONTRACT_VERSION,
       alg: ENVELOPE_ALG,
       cek_derivation: 'HKDF-SHA256',
       key_ref: keyRef,
@@ -327,9 +330,18 @@ function createExternalKeyGrant(options = {}) {
     shared = crypto.diffieHellman({ privateKey: ephemeral.privateKey, publicKey: deviceKey });
     const salt = wrapSalt ? Buffer.from(wrapSalt) : crypto.randomBytes(16);
     if (salt.length !== 16) fail('KDNA_GRANT_FORMAT_INVALID', 'grant wrap salt must be 16 bytes');
-    kek = hkdfSha256(shared, salt, Buffer.from(`${DEVICE_KEK_PROFILE}\n${grantId}`, 'utf8'), 32);
+    kek = hkdfSha256(
+      shared,
+      salt,
+      Buffer.from(
+        `${DEVICE_KEK_PROFILE}\n${EXTERNAL_GRANT_CONTRACT_VERSION}\n${grantId}`,
+        'utf8',
+      ),
+      32,
+    );
     const grant = {
       profile: EXTERNAL_GRANT_PROFILE,
+      contract_version: EXTERNAL_GRANT_CONTRACT_VERSION,
       grant_id: grantId,
       issuer,
       signing_key_id: signingKeyId,
@@ -339,7 +351,7 @@ function createExternalKeyGrant(options = {}) {
       device_public_key: devicePublicKey,
       device_signing_public_key: deviceSigningPublicKey,
       asset: {
-        asset_id: manifest.asset_id || manifest.name,
+        asset_id: manifest.asset_id,
         asset_uid: manifest.asset_uid,
         version: manifest.version,
         digest: assetDigest,
@@ -402,7 +414,7 @@ function authorizeExternalKeyGrant(options = {}) {
     grant,
     issuerPublicKeys,
     manifest,
-    checksums,
+    expectedAssetDigest,
     envelope: envelopeValue,
     deviceAgreementKey,
     expectedAccountId,
@@ -433,10 +445,15 @@ function authorizeExternalKeyGrant(options = {}) {
     'KDNA_GRANT_DEVICE_MISMATCH',
     'device signing key',
   );
-  expectEqual(grant.asset.asset_id, manifest.asset_id || manifest.name, 'KDNA_GRANT_ASSET_MISMATCH', 'asset ID');
+  expectEqual(grant.asset.asset_id, manifest.asset_id, 'KDNA_GRANT_ASSET_MISMATCH', 'asset ID');
   expectEqual(grant.asset.asset_uid, manifest.asset_uid, 'KDNA_GRANT_ASSET_MISMATCH', 'asset UID');
   expectEqual(grant.asset.version, manifest.version, 'KDNA_GRANT_ASSET_MISMATCH', 'asset version');
-  expectEqual(grant.asset.digest, checksums?.asset_digest, 'KDNA_GRANT_DIGEST_MISMATCH', 'asset digest');
+  expectEqual(
+    grant.asset.digest,
+    expectedAssetDigest,
+    'KDNA_GRANT_DIGEST_MISMATCH',
+    'asset digest',
+  );
   expectEqual(grant.asset.entry_path, envelope.entry_path, 'KDNA_GRANT_ASSET_MISMATCH', 'entry path');
   expectEqual(grant.asset.key_ref, envelope.key_ref, 'KDNA_GRANT_ASSET_MISMATCH', 'key reference');
   expectEqual(grant.asset.issuer_key_id, envelope.issuer_key_id, 'KDNA_GRANT_ASSET_MISMATCH', 'issuer asset key');
@@ -454,7 +471,15 @@ function authorizeExternalKeyGrant(options = {}) {
   const ephemeralKey = publicKeyFromRaw('X25519', `x25519:${b64url(ephemeralRaw)}`);
   const shared = crypto.diffieHellman({ privateKey, publicKey: ephemeralKey });
   const salt = decodeB64url(grant.wrap.salt, 'grant wrap salt', 16);
-  const kek = hkdfSha256(shared, salt, Buffer.from(`${DEVICE_KEK_PROFILE}\n${grant.grant_id}`, 'utf8'), 32);
+  const kek = hkdfSha256(
+    shared,
+    salt,
+    Buffer.from(
+      `${DEVICE_KEK_PROFILE}\n${EXTERNAL_GRANT_CONTRACT_VERSION}\n${grant.grant_id}`,
+      'utf8',
+    ),
+    32,
+  );
   let cek;
   try {
     cek = aesUnwrap(kek, decodeB64url(grant.wrap.wrapped_cek, 'wrapped CEK', 40));
@@ -543,6 +568,7 @@ module.exports = {
   EXTERNAL_GRANT_PROFILE,
   EXTERNAL_AAD_PROFILE,
   DEVICE_KEK_PROFILE,
+  EXTERNAL_GRANT_CONTRACT_VERSION,
   KDNAExternalGrantError,
   canonicalJson,
   grantSigningPayload,

package/src/index.js

@@ -2,7 +2,6 @@
  * @aikdna/kdna-core — CJS entry point
  */
 const loader = require('./loader');
-const lint = require('./lint-pure');
 const validate = require('./validate-pure');
 const render = require('./render');
 const compose = require('./compose');
@@ -11,13 +10,15 @@ const cryptoProfile = require('./crypto-profile');
 const externalKeyGrant = require('./external-key-grant');
 const publicApi = require('./public-api');
 const workpackPure = require('./workpack-pure');
-const v1 = require('./v1');
+const container = require('./container');
 const runtimeApi = require('./runtime-api');
+const runtimeCapsule = require('./runtime-capsule');
+const runtimeContract = require('./runtime-contract');
+const loaderCompatibility = require('./loader-compatibility');
 
 module.exports = {
   ...publicApi,
   ...loader,
-  ...lint,
   ...validate,
   ...render,
   ...compose,
@@ -25,6 +26,12 @@ module.exports = {
   ...cryptoProfile,
   ...externalKeyGrant,
   ...workpackPure,
-  ...v1,
+  ...container,
   ...runtimeApi,
+  ...runtimeCapsule,
+  ...runtimeContract,
+  STRICT_LOADER_VERSION: loaderCompatibility.STRICT_LOADER_VERSION,
+  parseLoaderVersion: loaderCompatibility.parseLoaderVersion,
+  compareLoaderVersions: loaderCompatibility.compareLoaderVersions,
+  assessLoaderCompatibility: loaderCompatibility.assessLoaderCompatibility,
 };