@aikdna/kdna-core 0.15.11 → 0.16.0

package/CHANGELOG.md

@@ -1,5 +1,65 @@
 # Changelog
 
+## v0.16.0 (2026-07-13)
+
+### Added
+
+- RFC-0019 external account/device key grants, schemas, deterministic golden
+  and negative fixtures, and JS/Swift parity vectors.
+- JS Core helpers for external envelope encryption, per-device grant issuance,
+  signature/binding verification, in-memory decryption, and explicit zeroization.
+- LoadPlan accepts only a runtime-verified external entitlement for account/org
+  assets; structurally similar status objects no longer authorize loading.
+- Reject authoring source directories at the public runtime API boundary;
+  `planLoad`, `load`, `loadAsset`, and `loadAuthorized` now require a packaged
+  `.kdna` file, including resolver-provided dependencies.
+- Regenerate authorization conformance fixtures from packaged assets and keep
+  source directories available only to authoring operations such as inspect,
+  validate, pack, and unpack.
+- Remove stale public format-generation wording and local coordination-path
+  assumptions from protocol documentation and public audit scripts.
+- Make release readiness fail for dirty inputs or when the selected version
+  tag does not point to the current commit.
+
+### Security
+
+- Account/device envelopes never fall back to the password profile.
+- Revoked, expired, tampered, digest/version/account/device mismatches fail
+  closed before Runtime Capsule projection.
+
+## v0.15.12 (2026-07-12)
+
+**Single-format refactor + CBOR wire contract + Runtime Capsule.**
+
+### Breaking changes
+
+- `MIMETYPE_V1`, `MIMETYPE_V2`, `MIMETYPE_LEGACY`, `isV1SourceDir`, `isV2SourceDir`
+  removed from public API. Use `MIMETYPE`, `isKdnaSourceDir`, `detectContainerFormat`.
+- `detectContainerFormat` returns only `"kdna"` or `null`.
+- `kdna_version: "2.0"` is no longer accepted. Only `"1.0"`.
+- `payload.encoding` accepts only `"cbor"`. JSON payload bytes are rejected;
+  there is no production JSON fallback.
+- Version-qualified public APIs (`V1_REQUIRED_DIR_ENTRIES`, `readV1Layout`,
+  `buildChecksumsV1`, `loadV1`, and the `./v1` export) are removed. Use the
+  unversioned APIs below.
+- `kdna load --as=json` now returns Runtime Capsule format
+  (`type: "kdna.context.capsule"`) instead of raw `{status, content}`.
+
+### Added
+
+- `REQUIRED_DIR_ENTRIES`, `readLayout`, `buildChecksums`, `load`, and
+  `loadAsset` are the sole public container/loading APIs.
+- `buildCapsule(loadResult, v1, profile, opts)` — wraps load output as
+  `kdna.context.capsule` per `specs/runtime-capsule.md`.
+- `parsePayloadEntry` — strict CBOR decoding for `payload.kdnab`.
+
+### Fixes
+
+- Producer/consumer encoding alignment: `dev-pack.js`, `studio.js` write CBOR;
+  validation and loading decode CBOR, including encrypted envelopes.
+- `loadV1Unsafe` extends/deps processing occurs before Capsule wrapping (Story 12 fix).
+- All test fixtures converted to CBOR; golden files regenerated.
+
 ## v0.15.11 (2026-07-03)
 
 **Fix**: repair Core v1 container dispatcher module resolution in the

package/README.md

@@ -1,10 +1,9 @@
 # @aikdna/kdna-core
 
-Core library for local `.kdna` judgment assets.
-
-KDNA Core v1 defines the `.kdna` file format, schemas, secure container
-reader, LoadPlan contract, and runtime projection helpers used by the CLI,
-Studio export, skills, MCP integrations, and downstream agent runtimes.
+Core library for `.kdna` judgment assets. It implements the single KDNA Asset
+Container, strict-CBOR payload decoding, validation, LoadPlan authorization,
+and Runtime Capsule projection used by the CLI, Studio, skills, MCP
+integrations, and downstream Agent runtimes.
 
 ## Installation
 
@@ -18,9 +17,10 @@ If you need full JSON Schema validation through Ajv, also install:
 npm install ajv ajv-formats
 ```
 
-## KDNA Core v1 API
+## Public API
 
-Use the `./v1` entrypoint for current KDNA Core v1 tooling:
+Use the package root. Version-qualified entrypoints and API names are not part
+of the public contract.
 
 ```js
 const {
@@ -30,8 +30,8 @@ const {
   loadAuthorized,
   pack,
   unpack,
-  buildChecksumsV1
-} = require('@aikdna/kdna-core/v1');
+  buildChecksums
+} = require('@aikdna/kdna-core');
 
 const validation = validate('./asset.kdna');
 if (!validation.overall_valid) {
@@ -43,10 +43,14 @@ if (plan.can_load_now !== true) {
   throw new Error(`Asset is not loadable yet: ${plan.required_action}`);
 }
 
-const compact = loadAuthorized('./asset.kdna', {
+const capsule = loadAuthorized('./asset.kdna', {
   profile: 'compact',
-  as: 'prompt'
+  as: 'json'
 });
+
+if (capsule.type !== 'kdna.context.capsule') {
+  throw new Error('Expected a Runtime Capsule');
+}
 ```
 
 ## Supported Runtime Flow
@@ -56,7 +60,8 @@ const compact = loadAuthorized('./asset.kdna', {
 → validate
 → planLoad
 → loadAuthorized
-→ agent/runtime context
+→ Runtime Capsule
+→ Agent/runtime context
 ```
 
 For authoring and test fixtures, `pack()` can turn a local working folder into
@@ -71,9 +76,9 @@ local working folder
 → loadAuthorized
 ```
 
-## v1 Container
+## KDNA Asset Container
 
-A v1 `.kdna` container contains:
+A `.kdna` asset contains:
 
 - `mimetype`
 - `kdna.json`
@@ -88,6 +93,22 @@ A v1 `.kdna` container contains:
 - checksum consistency
 - load-profile contract
 
+`payload.kdnab` is CBOR. A password-protected or licensed asset stores a CBOR
+encryption envelope in the same entry; authorized plaintext is decrypted in
+memory and projected into the Runtime Capsule.
+
+### Account/device external grants
+
+RFC-0019 licensed assets can keep the encrypted container publicly available
+while an issuer grants independent account/device access. `authorizeExternalKeyGrant()`
+verifies the issuer signature, lease, revocation state, account, device, asset
+UID/version/digest, and encrypted entry before returning a branded entitlement
+and in-memory decrypt hook. A plain `{status: "active"}` object is not accepted.
+
+Device private keys belong in the platform SecretStore. The returned session
+must be disposed after loading; Agent-facing callers should receive only the
+Runtime Capsule. Account grants never fall back to the password profile.
+
 ## Load Profiles
 
 `loadAuthorized()` supports:
@@ -104,15 +125,9 @@ Output formats:
 
 ## Boundary
 
-KDNA Core v1 is content-neutral. It validates file structure and loadability;
+KDNA Core is content-neutral. It validates file structure and loadability;
 it does not rank judgment quality or endorse specific assets.
 
-## Legacy API
-
-The package root still exports compatibility APIs for older KDNA paths. New
-tooling should prefer `@aikdna/kdna-core/v1` and the `planLoad` /
-`loadAuthorized` path.
-
 ## License
 
 Apache-2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@aikdna/kdna-core",
-    "version": "0.15.11",
+    "version": "0.16.0",
     "description": "KDNA Core library for validating, planning, and loading local .kdna judgment assets.",
     "engines": {
         "node": ">=18.0.0"
@@ -15,12 +15,7 @@
             "types": "./src/types.d.ts"
         },
         "./package.json": "./package.json",
-        "./schema/*": "./schema/*",
-        "./v1": {
-            "import": "./src/v1/index.mjs",
-            "require": "./src/v1/index.js",
-            "types": "./src/types.d.ts"
-        }
+        "./schema/*": "./schema/*"
     },
     "types": "src/types.d.ts",
     "scripts": {

package/schema/kdna-envelope-external-grant-v1.schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://kdna.ai/specs/kdna-envelope-external-grant-v1.schema.json",
+  "title": "KDNA external grant envelope v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["profile", "alg", "cek_derivation", "key_ref", "issuer_key_id", "entry_path", "plaintext_digest", "iv", "tag", "ciphertext"],
+  "properties": {
+    "profile": { "const": "kdna-envelope-external-grant-v1" },
+    "alg": { "const": "A256GCM" },
+    "cek_derivation": { "const": "HKDF-SHA256" },
+    "key_ref": { "type": "string", "minLength": 1, "maxLength": 256 },
+    "issuer_key_id": { "type": "string", "minLength": 1, "maxLength": 128 },
+    "entry_path": { "type": "string", "pattern": "^[^/].*[^/]$|^[^/]$", "maxLength": 256 },
+    "plaintext_digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "iv": { "type": "string", "pattern": "^[A-Za-z0-9_-]{16}$" },
+    "tag": { "type": "string", "pattern": "^[A-Za-z0-9_-]{22}$" },
+    "ciphertext": { "type": "string", "minLength": 1, "pattern": "^[A-Za-z0-9_-]+$" }
+  }
+}

package/schema/kdna-key-grant-v1.schema.json

@@ -0,0 +1,54 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://kdna.ai/specs/kdna-key-grant-v1.schema.json",
+  "title": "KDNA account/device external key grant v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["profile", "grant_id", "issuer", "signing_key_id", "entitlement_id", "account_id", "device_id", "device_public_key", "device_signing_public_key", "asset", "issued_at", "refresh_after", "offline_grace_until", "expires_at", "status", "status_version", "wrap", "signature"],
+  "properties": {
+    "profile": { "const": "kdna-key-grant-v1" },
+    "grant_id": { "$ref": "#/$defs/id" },
+    "issuer": { "type": "string", "format": "uri", "maxLength": 256 },
+    "signing_key_id": { "$ref": "#/$defs/id" },
+    "entitlement_id": { "$ref": "#/$defs/id" },
+    "account_id": { "$ref": "#/$defs/id" },
+    "device_id": { "$ref": "#/$defs/id" },
+    "device_public_key": { "type": "string", "pattern": "^x25519:[A-Za-z0-9_-]{43}$" },
+    "device_signing_public_key": { "type": "string", "pattern": "^ed25519:[A-Za-z0-9_-]{43}$" },
+    "asset": {
+      "type": "object", "additionalProperties": false,
+      "required": ["asset_id", "asset_uid", "version", "digest", "entry_path", "ciphertext_digest", "key_ref", "issuer_key_id"],
+      "properties": {
+        "asset_id": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "asset_uid": { "type": "string", "minLength": 1, "maxLength": 512 },
+        "version": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "digest": { "$ref": "#/$defs/digest" },
+        "entry_path": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "ciphertext_digest": { "$ref": "#/$defs/digest" },
+        "key_ref": { "type": "string", "minLength": 1, "maxLength": 256 },
+        "issuer_key_id": { "$ref": "#/$defs/id" }
+      }
+    },
+    "issued_at": { "type": "string", "format": "date-time" },
+    "refresh_after": { "type": "string", "format": "date-time" },
+    "offline_grace_until": { "type": "string", "format": "date-time" },
+    "expires_at": { "type": "string", "format": "date-time" },
+    "status": { "enum": ["active", "revoked", "expired"] },
+    "status_version": { "type": "integer", "minimum": 1 },
+    "wrap": {
+      "type": "object", "additionalProperties": false,
+      "required": ["alg", "ephemeral_public_key", "salt", "wrapped_cek"],
+      "properties": {
+        "alg": { "const": "X25519-HKDF-SHA256+A256KW" },
+        "ephemeral_public_key": { "type": "string", "pattern": "^x25519:[A-Za-z0-9_-]{43}$" },
+        "salt": { "type": "string", "pattern": "^[A-Za-z0-9_-]{22}$" },
+        "wrapped_cek": { "type": "string", "pattern": "^[A-Za-z0-9_-]{54}$" }
+      }
+    },
+    "signature": { "type": "string", "pattern": "^ed25519:[A-Za-z0-9_-]{86}$" }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[A-Za-z0-9._:@/-]{1,256}$" },
+    "digest": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" }
+  }
+}

package/schema/load-plan.schema.json

@@ -2,7 +2,7 @@
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "$id": "https://github.com/aikdna/kdna/schema/load-plan.schema.json",
   "title": "KDNA LoadPlan v1",
-  "description": "Machine-readable pre-load authorization and runtime planning result for KDNA Core v1 assets.",
+  "description": "Machine-readable pre-load authorization and runtime planning result for packaged KDNA assets.",
   "type": "object",
   "required": [
     "kdna_version",

package/schema/manifest.schema.json

@@ -22,8 +22,8 @@
   "properties": {
     "kdna_version": {
       "type": "string",
-      "description": "KDNA Core version this manifest conforms to.",
-      "enum": ["1.0", "2.0"]
+      "description": "KDNA Asset Container wire discriminator.",
+      "enum": ["1.0"]
     },
     "asset_id": {
       "type": "string",
@@ -102,7 +102,7 @@
       "additionalProperties": true,
       "properties": {
         "path": { "type": "string", "const": "payload.kdnab" },
-        "encoding": { "type": "string", "enum": ["json", "cbor"] },
+        "encoding": { "type": "string", "enum": ["cbor"] },
         "encrypted": { "type": "boolean" }
       }
     },

package/src/asset-reader.js

@@ -8,7 +8,7 @@ const zlib = require('zlib');
 const cbor = require('cbor-x');
 const { loadDomainFromFiles, formatContext } = require('./loader');
 
-const KDNA_MEDIA_TYPE = 'application/vnd.aikdna.kdna+zip';
+const KDNA_MEDIA_TYPE = 'application/vnd.kdna.asset';
 
 // Standard KDNA domain data entries — kept in lockstep with loader.FILE_MAP.
 // Asset reader pre-loads these so callers don't have to enumerate entry names.
@@ -363,19 +363,18 @@ function verifyHumanLockSignatures(coreData, manifest, errors, warnings) {
 
 function validateManifestIdentity(manifest, errors, _warnings) {
   if (manifest.kdna_spec) {
-    errors.push('kdna.json: kdna_spec is not allowed. Use spec_version.');
+    errors.push('kdna.json: kdna_spec is not allowed. Use kdna_version.');
   }
   if (manifest.format && manifest.format !== 'kdna') {
     errors.push(`kdna.json.format: invalid value "${manifest.format}". Expected "kdna".`);
   }
-  if (manifest.format_version && manifest.format_version !== '2.0') {
+  if (!manifest.kdna_version) {
+    errors.push('kdna.json: missing required field "kdna_version"');
+  } else if (manifest.kdna_version !== '1.0') {
     errors.push(
-      `kdna.json.format_version: invalid value "${manifest.format_version}". Expected "2.0".`,
+      `kdna.json.kdna_version: invalid value "${manifest.kdna_version}". Expected "1.0".`,
     );
   }
-  if (!manifest.spec_version) errors.push('kdna.json: missing required field "spec_version"');
-  if (!manifest.format) errors.push('kdna.json: missing required field "format"');
-  if (!manifest.format_version) errors.push('kdna.json: missing required field "format_version"');
   if (manifest.language) {
     errors.push('kdna.json: language is not allowed. Use default_language and languages.');
   }
@@ -624,10 +623,7 @@ function createKdnaAssetReader() {
 
       if (!asset.entries.has('kdna.json')) errors.push('required entry missing: kdna.json');
       verifyMediaType(asset, errors);
-      if (!asset.entries.has('KDNA_Core.json')) errors.push('required entry missing: KDNA_Core.json');
-      if (!asset.entries.has('KDNA_Patterns.json')) {
-        errors.push('required entry missing: KDNA_Patterns.json');
-      }
+      if (!asset.entries.has('payload.kdnab')) errors.push('required entry missing: payload.kdnab');
 
       const content_digest = buildContentDigest(asset);
       const asset_digest = asset.asset_digest;

package/src/container-dispatcher.js

@@ -4,45 +4,25 @@ const fs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
 
-const { createKdnaAssetReader } = require('./asset-reader.js');
-
-const MIMETYPE_V1 = 'application/vnd.kdna.asset';
-const MIMETYPE_V2 = 'application/vnd.aikdna.kdna+zip';
+const MIMETYPE = 'application/vnd.kdna.asset';
 
 /**
- * CanonicalAssetModel — the single internal representation of any KDNA asset,
- * regardless of whether it came from a source directory, Container v1,
- * or Canonical Distribution Container (Container v2 / SPEC 2.0).
- *
- * All downstream code (planLoad, loadAuthorized, decrypt, loadV1Unsafe)
- * operates on this model. No consumer should check container format directly.
+ * CanonicalAssetModel — the single internal representation of a KDNA asset,
+ * regardless of source (directory or .kdna container).
  *
  * @typedef {object} CanonicalAssetModel
- * @property {'dir'|'file'} sourceKind       — original input type
- * @property {string}       sourcePath       — resolved absolute path
- * @property {string}       format           — 'v1-dir' | 'v1-container' | 'v2-container'
- * @property {string}       mimetype         — normalized mimetype
+ * @property {'dir'|'file'} sourceKind
+ * @property {string}       sourcePath
+ * @property {string}       format           — 'dir' | 'kdna'
+ * @property {string}       mimetype
  * @property {object}       manifest         — parsed kdna.json
- * @property {Buffer}       payloadRaw       — raw payload.kdnab bytes (CBOR/JSON)
- * @property {object|null}  checksums        — parsed checksums.json, or null
- * @property {Buffer|null}  assetDigest      — SHA-256 of entire container (file only)
- * @property {Buffer|null}  containerBuffer  — full container bytes (for ZIP inputs, may be null for dirs)
- * @property {Map<string, Buffer>|null} entries — raw entry map (for v1 dir layout; null for v2/container)
+ * @property {Buffer}       payloadRaw       — raw payload.kdnab bytes
+ * @property {object|null}  checksums
+ * @property {Buffer|null}  assetDigest
+ * @property {Buffer|null}  containerBuffer
+ * @property {Map<string, Buffer>|null} entries
  */
 
-/**
- * Read any KDNA asset into a CanonicalAssetModel.
- *
- * Handles:
- *   - Source directories (mimetype + kdna.json + payload.kdnab on disk)
- *   - Container v1 (.kdna ZIP with application/vnd.kdna.asset mimetype)
- *   - Canonical containers (.kdna ZIP with application/vnd.aikdna.kdna+zip mimetype)
- *
- * @param {string} inputPath - absolute path to asset file or directory
- * @param {object} [opts]
- * @param {object} [opts.limits] - container size/entry limits
- * @returns {CanonicalAssetModel}
- */
 function readAsset(inputPath, opts = {}) {
   const absPath = path.resolve(inputPath);
   const stat = fs.statSync(absPath);
@@ -59,11 +39,8 @@ function readAsset(inputPath, opts = {}) {
   }
 
   const format = detectFormat(absPath);
-  if (format === 'v1-container') {
-    return readV1Container(absPath, opts);
-  }
-  if (format === 'v2-container') {
-    return readV2Container(absPath, opts);
+  if (format === 'kdna') {
+    return readKdnaContainer(absPath, opts);
   }
 
   throw Object.assign(
@@ -72,10 +49,6 @@ function readAsset(inputPath, opts = {}) {
   );
 }
 
-/**
- * Detect the container format of a .kdna file.
- * Returns 'v1-container', 'v2-container', or throws.
- */
 function detectFormat(absPath) {
   const buf = fs.readFileSync(absPath);
   if (buf.length < 4) {
@@ -85,7 +58,6 @@ function detectFormat(absPath) {
     );
   }
 
-  // Must be a ZIP (PK signature)
   const sig = buf.readUInt32LE(0);
   if (sig !== 0x04034b50) {
     throw Object.assign(
@@ -94,7 +66,6 @@ function detectFormat(absPath) {
     );
   }
 
-  // Read the mimetype from the first entry (central directory first entry)
   const eocdOffset = findEocd(buf);
   let cdOffset = buf.readUInt32LE(eocdOffset + 16);
   const cdEntryCount = buf.readUInt16LE(eocdOffset + 10);
@@ -126,8 +97,7 @@ function detectFormat(absPath) {
     const compressedSize = buf.readUInt32LE(entryOffset + 20);
     const mime = buf.toString('utf8', dataOffset, dataOffset + compressedSize).trim();
 
-    if (mime === MIMETYPE_V1) return 'v1-container';
-    if (mime === MIMETYPE_V2) return 'v2-container';
+    if (mime === MIMETYPE) return 'kdna';
 
     throw Object.assign(
       new Error(`Unknown KDNA mimetype: ${mime}`),
@@ -154,9 +124,6 @@ function findEocd(buf) {
   );
 }
 
-/**
- * Read a source directory into CanonicalAssetModel.
- */
 function readSourceDirectory(absPath, _opts) {
   const mimetypePath = path.join(absPath, 'mimetype');
   const manifestPath = path.join(absPath, 'kdna.json');
@@ -171,7 +138,7 @@ function readSourceDirectory(absPath, _opts) {
   }
 
   const mimetype = fs.readFileSync(mimetypePath, 'utf8').trim();
-  if (![MIMETYPE_V1, MIMETYPE_V2].includes(mimetype)) {
+  if (mimetype !== MIMETYPE) {
     throw Object.assign(
       new Error(`Unknown mimetype in source directory: ${mimetype}`),
       { code: 'KDNA_FORMAT_UNKNOWN' },
@@ -204,7 +171,7 @@ function readSourceDirectory(absPath, _opts) {
   return {
     sourceKind: 'dir',
     sourcePath: absPath,
-    format: 'v1-dir',
+    format: 'dir',
     mimetype,
     manifest,
     payloadRaw,
@@ -215,21 +182,16 @@ function readSourceDirectory(absPath, _opts) {
   };
 }
 
-/**
- * Read a Container v1 (.kdna with v1 mimetype) into CanonicalAssetModel.
- */
-function readV1Container(absPath, _opts) {
-  // Delegate to the existing v1 layout reader for validation
-  const v1Layout = require('./v1/index.js').readV1Layout(absPath);
-
+function readKdnaContainer(absPath, _opts) {
+  const v1Layout = require('./v1/index.js').readLayout(absPath);
   const containerBuf = fs.readFileSync(absPath);
   const assetDigest = crypto.createHash('sha256').update(containerBuf).digest();
 
   return {
     sourceKind: 'file',
     sourcePath: absPath,
-    format: 'v1-container',
-    mimetype: MIMETYPE_V1,
+    format: 'kdna',
+    mimetype: MIMETYPE,
     manifest: v1Layout.manifest,
     payloadRaw: v1Layout.map['payload.kdnab'] || null,
     checksums: v1Layout.map['checksums.json']
@@ -241,58 +203,18 @@ function readV1Container(absPath, _opts) {
   };
 }
 
-/**
- * Read a Canonical Container (v2 mimetype) into CanonicalAssetModel.
- * Uses the existing KdnaAssetReader for ZIP parsing.
- */
-function readV2Container(absPath, _opts) {
-  const reader = createKdnaAssetReader();
-  const asset = reader.openSync(absPath);
-
-  const manifest = reader.readManifestSync(asset);
-  const payloadRaw = reader.readEntrySync(asset, 'payload.kdnab');
-  const checksums = (() => {
-    try {
-      const raw = reader.readEntrySync(asset, 'checksums.json');
-      return raw ? JSON.parse(raw.toString('utf8')) : null;
-    } catch {
-      return null;
-    }
-  })();
-
-  return {
-    sourceKind: 'file',
-    sourcePath: absPath,
-    format: 'v2-container',
-    mimetype: MIMETYPE_V2,
-    manifest,
-    payloadRaw,
-    checksums,
-    assetDigest: Buffer.from(asset.asset_digest.replace(/^sha256:/, ''), 'hex'),
-    containerBuffer: fs.readFileSync(absPath),
-    entries: null, // v2 uses lazy reads, not pre-loaded map
-  };
-}
-
-/**
- * Extract the mimetype from a CanonicalAssetModel.
- */
 function getMimetype(asset) {
   return asset.mimetype;
 }
 
-/**
- * Determine if a CanonicalAssetModel represents a source directory.
- */
-function isSourceDirectory(asset) {
+function isKdnaSourceDirectory(asset) {
   return asset.sourceKind === 'dir';
 }
 
 module.exports = {
-  MIMETYPE_V1,
-  MIMETYPE_V2,
+  MIMETYPE,
   readAsset,
   detectFormat,
   getMimetype,
-  isSourceDirectory,
+  isKdnaSourceDirectory,
 };

package/src/crypto-profile.js

@@ -1,4 +1,5 @@
 const crypto = require('crypto');
+const cbor = require('cbor-x');
 
 let argon2id;
 try {
@@ -56,11 +57,13 @@ function decodeBase64(value, label) {
 
 function normalizeEnvelope(value) {
   if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
-    return JSON.parse(Buffer.from(value).toString('utf8'));
+    try { return cbor.decode(Buffer.from(value)); } catch { /* fall through */ }
+  }
+  if (typeof value === 'string') {
+    try { return cbor.decode(Buffer.from(value, 'utf8')); } catch { /* fall through */ }
   }
-  if (typeof value === 'string') return JSON.parse(value);
   if (value && typeof value === 'object') return value;
-  throw new Error('encrypted entry envelope must be JSON');
+  throw new Error('encrypted entry envelope must be CBOR (kdna_version 1.0)');
 }
 
 function encryptedEntryAad(entryName, manifest = {}, profile = LICENSED_ENTRY_PROFILE) {