@aikdna/kdna-core 0.16.0 → 0.18.0

package/src/index.js

@@ -13,6 +13,8 @@ const publicApi = require('./public-api');
 const workpackPure = require('./workpack-pure');
 const v1 = require('./v1');
 const runtimeApi = require('./runtime-api');
+const capsuleV2 = require('./capsule-v2');
+const executionContractV1 = require('./execution-contract-v1');
 
 module.exports = {
   ...publicApi,
@@ -27,4 +29,6 @@ module.exports = {
   ...workpackPure,
   ...v1,
   ...runtimeApi,
+  ...capsuleV2,
+  ...executionContractV1,
 };

package/src/index.mjs

@@ -10,7 +10,7 @@ export {
   formatContext,
 } from './loader.js';
 
-export { lintDomain } from './lint-pure.js';
+export { lintDomain, validateManifest } from './lint-pure.js';
 
 export {
   MIMETYPE,
@@ -40,30 +40,145 @@ export { validateDomainSchema, validateCrossFile } from './validate-pure.js';
 
 export { renderPreviewHTML, escHtml, renderCard } from './render.js';
 
-export { composeContext, composeContextWithAttribution, classifySignals, classifySignalsAcrossDomains, composeChecks, loadAndCompose, loadCluster, detectDomainConflicts, generateClusterTrace } from './compose.js';
+export {
+  composeContext,
+  composeContextWithAttribution,
+  classifySignals,
+  classifySignalsAcrossDomains,
+  composeChecks,
+  loadAndCompose,
+  loadCluster,
+  detectDomainConflicts,
+  generateClusterTrace,
+} from './compose.js';
 
 import assetReader from './asset-reader.js';
 import cryptoProfile from './crypto-profile.js';
 import externalKeyGrant from './external-key-grant.js';
+import publicApi from './public-api.js';
+import workpackPure from './workpack-pure.js';
+import capsuleV2 from './capsule-v2.js';
+import executionContractV1 from './execution-contract-v1.js';
+
+export const openKDNA = publicApi.openKDNA;
+export const openKDNASync = publicApi.openKDNASync;
+export const inspectKDNA = publicApi.inspectKDNA;
+export const inspectKDNASync = publicApi.inspectKDNASync;
+export const loadKDNA = publicApi.loadKDNA;
+export const loadKDNASync = publicApi.loadKDNASync;
+export const validateKDNA = publicApi.validateKDNA;
+export const validateKDNASync = publicApi.validateKDNASync;
+export const renderForAgent = publicApi.renderForAgent;
+export const renderForAgentSync = publicApi.renderForAgentSync;
+export const verifyAsset = publicApi.verifyAsset;
+export const verifyAssetSync = publicApi.verifyAssetSync;
+export const verifyDigest = publicApi.verifyDigest;
+export const verifyDigestSync = publicApi.verifyDigestSync;
+export const verifySignature = publicApi.verifySignature;
+export const verifySignatureSync = publicApi.verifySignatureSync;
+export const matchDomain = publicApi.matchDomain;
+export const matchDomainSync = publicApi.matchDomainSync;
+export const composeKDNA = publicApi.composeKDNA;
+
+export const DIGEST_PROFILE = capsuleV2.DIGEST_PROFILE;
+export const CAPSULE_DIGEST_PROFILE = capsuleV2.CAPSULE_DIGEST_PROFILE;
+export const BASIS = capsuleV2.BASIS;
+export const computeAssetDigest = capsuleV2.computeAssetDigest;
+export const computeRuntimeEntrySetDigest = capsuleV2.computeRuntimeEntrySetDigest;
+export const computeDigestEvidence = capsuleV2.computeDigestEvidence;
+export const canonicalizeJcs = capsuleV2.canonicalizeJcs;
+export const computeCapsuleDeliveryDigest = capsuleV2.computeCapsuleDeliveryDigest;
+export const buildCapsuleV2 = capsuleV2.buildCapsuleV2;
+export const loadCapsuleV2 = capsuleV2.loadCapsuleV2;
+export const adaptCapsuleV2ToV1 = capsuleV2.adaptCapsuleV2ToV1;
+
+export const KDNAExecutionContractError = executionContractV1.KDNAExecutionContractError;
+export const PLAN_DIGEST_PROFILE = executionContractV1.PLAN_DIGEST_PROFILE;
+export const HOST_PROTOCOL = executionContractV1.HOST_PROTOCOL;
+export const DEFAULT_CORE_CAPSULE_VERSIONS = executionContractV1.DEFAULT_CORE_CAPSULE_VERSIONS;
+export const parseExecutionContractJsonV1 = executionContractV1.parseExecutionContractJsonV1;
+export const computeConsumptionPlanDigestV1 = executionContractV1.computeConsumptionPlanDigestV1;
+export const buildConsumptionPlanV1 = executionContractV1.buildConsumptionPlanV1;
+export const validateConsumptionPlanV1 = executionContractV1.validateConsumptionPlanV1;
+export const negotiateExecutionPairV1 = executionContractV1.negotiateExecutionPairV1;
+export const buildAgentHost2RequestV1 = executionContractV1.buildAgentHost2RequestV1;
+export const validateAgentHost2RequestV1 = executionContractV1.validateAgentHost2RequestV1;
+export const validateAgentHost2ReceiptV1 = executionContractV1.validateAgentHost2ReceiptV1;
+export const deriveBudgetEvidenceV1 = executionContractV1.deriveBudgetEvidenceV1;
+export const buildPreHostBudgetBlockedTraceV1 =
+  executionContractV1.buildPreHostBudgetBlockedTraceV1;
+export const validatePreHostBudgetBlockedTraceV1 =
+  executionContractV1.validatePreHostBudgetBlockedTraceV1;
+export const buildJudgmentTraceV1 = executionContractV1.buildJudgmentTraceV1;
+export const validateJudgmentTraceV1 = executionContractV1.validateJudgmentTraceV1;
 
 export const STANDARD_ENTRIES = assetReader.STANDARD_ENTRIES;
 export const createKdnaAssetReader = assetReader.createKdnaAssetReader;
-export const LICENSED_ENTRY_PROFILE = cryptoProfile.LICENSED_ENTRY_PROFILE;
-export const deriveLicensedEntryKey = cryptoProfile.deriveLicensedEntryKey;
-export const encryptLicensedEntry = cryptoProfile.encryptLicensedEntry;
-export const decryptLicensedEntry = cryptoProfile.decryptLicensedEntry;
-export const createLicensedDecryptEntry = cryptoProfile.createLicensedDecryptEntry;
-export const EXTERNAL_ENVELOPE_PROFILE = externalKeyGrant.EXTERNAL_ENVELOPE_PROFILE;
-export const EXTERNAL_GRANT_PROFILE = externalKeyGrant.EXTERNAL_GRANT_PROFILE;
-export const KDNAExternalGrantError = externalKeyGrant.KDNAExternalGrantError;
-export const canonicalJson = externalKeyGrant.canonicalJson;
-export const grantSigningPayload = externalKeyGrant.grantSigningPayload;
-export const validateExternalEnvelope = externalKeyGrant.validateExternalEnvelope;
-export const validateExternalKeyGrant = externalKeyGrant.validateExternalKeyGrant;
-export const deriveExternalAssetCek = externalKeyGrant.deriveExternalAssetCek;
-export const encodeExternalEnvelope = externalKeyGrant.encodeExternalEnvelope;
-export const decodeExternalEnvelope = externalKeyGrant.decodeExternalEnvelope;
-export const encryptExternalGrantEntry = externalKeyGrant.encryptExternalGrantEntry;
-export const generateDeviceKeyPairs = externalKeyGrant.generateDeviceKeyPairs;
-export const createExternalKeyGrant = externalKeyGrant.createExternalKeyGrant;
-export const authorizeExternalKeyGrant = externalKeyGrant.authorizeExternalKeyGrant;
+
+export const {
+  LICENSED_ENTRY_PROFILE,
+  LICENSED_EXPERIMENTAL_PROFILE,
+  PASSWORD_PROTECTED_PROFILE,
+  PASSWORD_PROTECTED_SCRYPT_PROFILE,
+  ALG,
+  RFC_KDF,
+  RFC_KEY_WRAPPING,
+  LEGACY_KDF,
+  PASSWORD_KDF,
+  SCRYPT_KDF,
+  deriveWrappingKey,
+  generateCEK,
+  wrapCEK,
+  unwrapCEK,
+  encryptLicensedEntryV1,
+  decryptLicensedEntryV1,
+  derivePasswordKey,
+  generateRecoveryCode,
+  decodeRecoveryCode,
+  encryptProtectedEntry,
+  decryptProtectedEntry,
+  createPasswordDecryptEntry,
+  createRecoveryDecryptEntry,
+  derivePasswordKeyScrypt,
+  encryptProtectedEntryScrypt,
+  decryptProtectedEntryScrypt,
+  createPasswordDecryptEntryScrypt,
+  deriveLicensedEntryKey,
+  encryptLicensedEntryLegacy,
+  decryptLicensedEntryLegacy,
+  encryptLicensedEntry,
+  decryptLicensedEntry,
+  createLicensedDecryptEntry,
+  hkdfSha256,
+  aesWrap,
+  aesUnwrap,
+} = cryptoProfile;
+
+export const {
+  EXTERNAL_ENVELOPE_PROFILE,
+  EXTERNAL_GRANT_PROFILE,
+  EXTERNAL_AAD_PROFILE,
+  DEVICE_KEK_PROFILE,
+  KDNAExternalGrantError,
+  canonicalJson,
+  grantSigningPayload,
+  validateExternalEnvelope,
+  validateExternalKeyGrant,
+  externalEnvelopeAad,
+  deriveExternalAssetCek,
+  encodeExternalEnvelope,
+  decodeExternalEnvelope,
+  encryptExternalGrantEntry,
+  generateDeviceKeyPairs,
+  createExternalKeyGrant,
+  authorizeExternalKeyGrant,
+  isVerifiedExternalEntitlement,
+} = externalKeyGrant;
+
+export const {
+  WORK_PACK_SCHEMA,
+  validateWorkPackManifest,
+  checkWorkPackStructure,
+  inspectWorkPack,
+  loadWorkPack,
+} = workpackPure;

package/src/lint-pure.js

@@ -253,8 +253,8 @@ function lintDomain(dataMap) {
 }
 
 /**
- * Canonical enum tables for manifest validation.
- * Single source of truth — keep in sync with schema/kdna-manifest-v1rc.json and specs/enum-tables.md.
+ * Legacy authoring-source enum tables for migration validation.
+ * These do not define the current Runtime manifest contract.
  */
 const VALID_STATUS = new Set(['draft', 'experimental', 'stable', 'deprecated', 'staging']);
 const VALID_BADGE = new Set(['untested', 'tested', 'validated', 'expert_reviewed', 'production_ready']);
@@ -279,7 +279,10 @@ const MANIFEST_REQUIRED = [
 ];
 
 /**
- * Validate a kdna.json manifest against the canonical KDNA Asset format.
+ * Validate a legacy authoring-source kdna.json manifest.
+ *
+ * This function is retained for explicit source migration. Current Runtime
+ * containers are validated against schema/manifest.schema.json by v1.validate.
  *
  * @param {Object} manifest — parsed kdna.json
  * @returns {{ errors: string[], warnings: string[] }}

package/src/public-api.js

@@ -1,22 +1,16 @@
 /**
- * Stable public API for third-party KDNA integrations.
+ * Compatibility names for the stable current KDNA Runtime API.
  *
- * Lower-level modules remain exported for advanced runtimes, but external
- * adapters should prefer these names. They encode the asset-first contract:
- * callers pass .kdna files or bytes, and no persistent directory extraction is
- * required.
+ * These names previously implemented a second legacy source-tree validator and
+ * loader. They now route to the same current inspect/validate/LoadPlan/Capsule
+ * implementation as the unversioned package API. No current payload is
+ * reverse-projected into KDNA_Core.json or KDNA_Patterns.json.
  */
 
+const fs = require('fs');
 const { createKdnaAssetReader } = require('./asset-reader');
-const { lintDomain } = require('./lint-pure');
-const { validateCrossFile, validateDomainSchema } = require('./validate-pure');
-const { formatContext } = require('./loader');
-const {
-  composeContextWithAttribution,
-  detectDomainConflicts,
-  classifySignalsAcrossDomains,
-  generateClusterTrace,
-} = require('./compose');
+const v1 = require('./v1');
+const runtimeApi = require('./runtime-api');
 
 function readerFrom(options = {}) {
   return options.reader || createKdnaAssetReader();
@@ -26,6 +20,18 @@ function isAsset(value) {
   return value && typeof value === 'object' && value.entries instanceof Map && typeof value.readEntry === 'function';
 }
 
+const ASSET_SOURCE_BYTES = Symbol.for('@aikdna/kdna-core.asset-source-bytes');
+
+function canonicalBytes(input) {
+  if (Buffer.isBuffer(input)) return input;
+  if (input instanceof Uint8Array) return Buffer.from(input);
+  if (typeof input === 'string') return fs.readFileSync(input);
+  if (isAsset(input) && Buffer.isBuffer(input[ASSET_SOURCE_BYTES])) {
+    return input[ASSET_SOURCE_BYTES];
+  }
+  throw new Error('KDNA operation expects a .kdna path, Buffer, Uint8Array, or asset opened by openKDNA');
+}
+
 async function asAsset(input, options = {}) {
   if (isAsset(input)) return input;
   return readerFrom(options).open(input);
@@ -47,156 +53,69 @@ function openKDNASync(input, options = {}) {
 async function inspectKDNA(input, options = {}) {
   const reader = readerFrom(options);
   const asset = await asAsset(input, { ...options, reader });
-  const profile = await reader.loadProfile(asset, 'index', options);
+  const current = v1.inspect(canonicalBytes(asset), options);
+  const manifest = await reader.readManifest(asset);
+  const entries = await reader.listEntries(asset);
+  const contentDigest = await reader.contentDigest(asset);
   const verification = options.verify === false ? null : await reader.verify(asset, options);
   return {
-    name: profile.name,
-    version: profile.version,
-    judgment_version: profile.judgment_version,
-    access: profile.manifest.access || 'open',
-    status: profile.manifest.status || null,
-    quality_badge: profile.manifest.quality_badge || null,
-    risk_level: profile.manifest.risk_level || null,
-    keywords: profile.keywords,
-    entries: profile.entries,
-    asset_digest: profile.asset_digest,
-    content_digest: profile.content_digest,
+    ...current,
+    entries,
+    asset_digest: asset.asset_digest,
+    content_digest: contentDigest,
     signature_valid: verification ? verification.signature_valid : null,
     ok: verification ? verification.ok : null,
     errors: verification ? verification.errors : [],
     warnings: verification ? verification.warnings : [],
-    manifest: profile.manifest,
+    manifest,
   };
 }
 
 function inspectKDNASync(input, options = {}) {
   const reader = readerFrom(options);
   const asset = asAssetSync(input, { ...options, reader });
-  const profile = reader.loadProfileSync(asset, 'index', options);
+  const current = v1.inspect(canonicalBytes(asset), options);
+  const manifest = reader.readManifestSync(asset);
+  const entries = reader.listEntriesSync(asset);
+  const contentDigest = reader.contentDigestSync(asset);
   const verification = options.verify === false ? null : reader.verifySync(asset, options);
   return {
-    name: profile.name,
-    version: profile.version,
-    judgment_version: profile.judgment_version,
-    access: profile.manifest.access || 'open',
-    status: profile.manifest.status || null,
-    quality_badge: profile.manifest.quality_badge || null,
-    risk_level: profile.manifest.risk_level || null,
-    keywords: profile.keywords,
-    entries: profile.entries,
-    asset_digest: profile.asset_digest,
-    content_digest: profile.content_digest,
+    ...current,
+    entries,
+    asset_digest: asset.asset_digest,
+    content_digest: contentDigest,
     signature_valid: verification ? verification.signature_valid : null,
     ok: verification ? verification.ok : null,
     errors: verification ? verification.errors : [],
     warnings: verification ? verification.warnings : [],
-    manifest: profile.manifest,
+    manifest,
   };
 }
 
 async function loadKDNA(input, options = {}) {
-  const reader = readerFrom(options);
-  const asset = await asAsset(input, { ...options, reader });
-  return reader.loadProfile(asset, options.profile || 'compact', options);
+  return runtimeApi.loadAuthorized(isAsset(input) ? canonicalBytes(input) : input, options);
 }
 
 function loadKDNASync(input, options = {}) {
-  const reader = readerFrom(options);
-  const asset = asAssetSync(input, { ...options, reader });
-  return reader.loadProfileSync(asset, options.profile || 'compact', options);
+  return runtimeApi.loadAuthorized(isAsset(input) ? canonicalBytes(input) : input, options);
 }
 
 async function validateKDNA(input, options = {}) {
-  const reader = readerFrom(options);
-  const asset = await asAsset(input, { ...options, reader });
-  const assetResult = await reader.verify(asset, options);
-  let dataMap;
-  let lintResult = { errors: [], warnings: [] };
-  let schemaResult = { errors: [], warnings: [] };
-  let crossFileResult = { errors: [], warnings: [] };
-
-  try {
-    dataMap = await reader.readDataMap(asset, undefined, options);
-    lintResult = lintDomain(dataMap);
-    schemaResult = validateDomainSchema(dataMap, options.schemas || {});
-    crossFileResult = validateCrossFile(dataMap);
-  } catch (e) {
-    lintResult.errors.push(e.message);
-  }
-
-  const errors = [
-    ...assetResult.errors,
-    ...lintResult.errors,
-    ...schemaResult.errors,
-    ...crossFileResult.errors,
-  ];
-  const warnings = [
-    ...assetResult.warnings,
-    ...lintResult.warnings,
-    ...schemaResult.warnings,
-    ...crossFileResult.warnings,
-  ];
-  return {
-    ok: errors.length === 0,
-    errors,
-    warnings,
-    asset: assetResult,
-    lint: lintResult,
-    schema: schemaResult,
-    cross_file: crossFileResult,
-  };
+  return v1.validate(isAsset(input) ? canonicalBytes(input) : input, options);
 }
 
 function validateKDNASync(input, options = {}) {
-  const reader = readerFrom(options);
-  const asset = asAssetSync(input, { ...options, reader });
-  const assetResult = reader.verifySync(asset, options);
-  let lintResult = { errors: [], warnings: [] };
-  let schemaResult = { errors: [], warnings: [] };
-  let crossFileResult = { errors: [], warnings: [] };
-
-  try {
-    const dataMap = reader.readDataMapSync(asset, undefined, options);
-    lintResult = lintDomain(dataMap);
-    schemaResult = validateDomainSchema(dataMap, options.schemas || {});
-    crossFileResult = validateCrossFile(dataMap);
-  } catch (e) {
-    lintResult.errors.push(e.message);
-  }
-
-  const errors = [
-    ...assetResult.errors,
-    ...lintResult.errors,
-    ...schemaResult.errors,
-    ...crossFileResult.errors,
-  ];
-  const warnings = [
-    ...assetResult.warnings,
-    ...lintResult.warnings,
-    ...schemaResult.warnings,
-    ...crossFileResult.warnings,
-  ];
-  return {
-    ok: errors.length === 0,
-    errors,
-    warnings,
-    asset: assetResult,
-    lint: lintResult,
-    schema: schemaResult,
-    cross_file: crossFileResult,
-  };
+  return v1.validate(isAsset(input) ? canonicalBytes(input) : input, options);
 }
 
 async function renderForAgent(input, options = {}) {
-  const loaded = await loadKDNA(input, options);
-  if (loaded.context != null) return loaded.context;
-  return loaded.domain ? formatContext(loaded.domain) : '';
+  const loaded = await loadKDNA(input, { ...options, as: 'prompt' });
+  return loaded && typeof loaded.text === 'string' ? loaded.text : '';
 }
 
 function renderForAgentSync(input, options = {}) {
-  const loaded = loadKDNASync(input, options);
-  if (loaded.context != null) return loaded.context;
-  return loaded.domain ? formatContext(loaded.domain) : '';
+  const loaded = loadKDNASync(input, { ...options, as: 'prompt' });
+  return loaded && typeof loaded.text === 'string' ? loaded.text : '';
 }
 
 async function verifyAsset(input, options = {}) {
@@ -230,8 +149,10 @@ function verifySignatureSync(input, options = {}) {
 function scoreMatch(input, info) {
   const haystack = String(input || '').toLowerCase();
   const terms = [
-    info.name,
-    ...(info.keywords || []),
+    info.asset_id,
+    info.title,
+    ...(info.keywords || info.manifest?.keywords || []),
+    info.summary || info.manifest?.summary,
     info.manifest?.description,
     info.manifest?.core_insight,
   ]
@@ -250,7 +171,7 @@ async function matchDomain(input, candidates, options = {}) {
     const match = scoreMatch(input, info);
     if (match.score > 0) results.push({ ...info, score: match.score, matched: match.matched });
   }
-  return results.sort((a, b) => b.score - a.score || String(a.name).localeCompare(String(b.name)));
+  return results.sort((a, b) => b.score - a.score || String(a.asset_id).localeCompare(String(b.asset_id)));
 }
 
 function matchDomainSync(input, candidates, options = {}) {
@@ -262,42 +183,17 @@ function matchDomainSync(input, candidates, options = {}) {
     const match = scoreMatch(input, info);
     if (match.score > 0) results.push({ ...info, score: match.score, matched: match.matched });
   }
-  return results.sort((a, b) => b.score - a.score || String(a.name).localeCompare(String(b.name)));
+  return results.sort((a, b) => b.score - a.score || String(a.asset_id).localeCompare(String(b.asset_id)));
 }
 
 async function composeKDNA(inputs, options = {}) {
-  const loaded = [];
-  for (const input of inputs || []) {
-    const profile = await loadKDNA(input, { ...options, profile: options.profile || 'compact', context: false });
-    if (profile.domain) {
-      loaded.push({
-        id: profile.manifest.name || profile.domain.core?.meta?.domain,
-        name: profile.manifest.name || profile.domain.core?.meta?.domain,
-        manifest: profile.manifest,
-        ...profile.domain,
-      });
-    }
-  }
-  const { selected, excluded } = classifySignalsAcrossDomains(options.input || '', loaded);
-  const selectedIds = new Set(selected.map((d) => d.id));
-  const activeDomains = options.input ? loaded.filter((d) => selectedIds.has(d.id)) : loaded;
-  const conflicts = detectDomainConflicts(activeDomains);
-  const { context, attributionMap } = composeContextWithAttribution(activeDomains, options);
-  return {
-    domains: loaded,
-    activeDomains,
-    selected,
-    excluded,
-    conflicts,
-    context,
-    attributionMap,
-    trace: generateClusterTrace({
-      input: options.input || '',
-      loadedDomains: loaded,
-      activeDomains,
-      conflicts,
-    }),
-  };
+  void inputs;
+  void options;
+  const error = new Error(
+    'composeKDNA is unavailable until the current Cluster/Capsule composition protocol is defined.',
+  );
+  error.code = 'KDNA_COMPOSE_PROTOCOL_UNAVAILABLE';
+  throw error;
 }
 
 module.exports = {

package/src/runtime-api.js

@@ -68,18 +68,17 @@ function planLoad(inputPath, options = {}) {
 }
 
 function loadAuthorized(inputPath, options = {}) {
-  const plan = planLoad(inputPath, options);
-  if (plan.can_load_now !== true) {
-    const issueCodes = Array.isArray(plan.issues)
-      ? plan.issues.map((issue) => issue.code).filter(Boolean)
-      : [];
+  if (isDirectory(inputPath)) {
+    const plan = invalidDirectoryPlan(inputPath);
     const error = new Error(
       `LoadPlan denied loading: state=${plan.state || 'invalid'} required_action=${plan.required_action || 'block'}`,
     );
-    error.code = issueCodes[0] || 'KDNA_LOAD_NOT_AUTHORIZED';
+    error.code = 'KDNA_ASSET_FILE_REQUIRED';
     error.plan = plan;
     throw error;
   }
+  // v1.loadAuthorized snapshots packaged paths once and uses that same Buffer
+  // for its LoadPlan, authorization decision, and Runtime Capsule projection.
   return v1.loadAuthorized(inputPath, guardResolver(options));
 }