@aikdna/kdna-core 0.20.0 → 0.21.0

package/src/container/index.js

@@ -18,7 +18,8 @@
  *   - mimetype must be the first entry in a .kdna container
  *   - mimetype must be STORED (compression method 0) in a .kdna container
  *   - the source directory must contain mimetype, kdna.json, payload.kdnab
- *   - checksums.json and signatures/ are optional
+ *   - checksums.json and attachments/ are optional
+ *   - asset signatures are outside the current Preview contract
  *   - lineage must be a single object (not an array)
  *   - pack output is reproducible within one pinned toolchain/compressor;
  *     DEFLATE bytes may differ across compressors, zlib versions, or systems
@@ -51,17 +52,46 @@ const {
   isVerifiedExternalEntitlement,
 } = require('../external-key-grant');
 
+function warnDispatcherDegraded(e) {
+  process.emitWarning(
+    `container-dispatcher failed to load; falling back to the legacy reader: ${e.message}`,
+    { code: 'KDNA_DISPATCHER_DEGRADED' },
+  );
+  return { readAsset: null };
+}
+
 const { readAsset } = (() => {
+  const dispatcherRequest = '../container-dispatcher.js';
+  // Absence check via require.resolve: resolution only inspects the module
+  // path and never executes the target, so it can only fail with
+  // MODULE_NOT_FOUND when the dispatcher file itself cannot be located.
+  // Message matching is intentionally not used: Node prints the require
+  // stack inside MODULE_NOT_FOUND messages, so a dispatcher whose own
+  // internal dependency is missing would mention "container-dispatcher"
+  // and be misclassified as absent.
   try {
-    return require('../container-dispatcher.js');
-  } catch {
-    return { readAsset: null };
+    require.resolve(dispatcherRequest);
+  } catch (e) {
+    if (e && e.code === 'MODULE_NOT_FOUND') {
+      // The dispatcher file is genuinely absent: expected in minimal
+      // installs. Fall back silently.
+      return { readAsset: null };
+    }
+    return warnDispatcherDegraded(e);
+  }
+  // The file resolved; any failure from here on (missing internal
+  // dependency, syntax error, initialization throw, permission error) is a
+  // real load failure and must be surfaced.
+  try {
+    return require(dispatcherRequest);
+  } catch (e) {
+    return warnDispatcherDegraded(e);
   }
 })();
 
 const MIMETYPE = 'application/vnd.kdna.asset';
 const REQUIRED_DIR_ENTRIES = ['mimetype', 'kdna.json', 'payload.kdnab'];
-const OPTIONAL_DIR_ENTRIES = ['checksums.json', 'signatures', 'attachments'];
+const OPTIONAL_DIR_ENTRIES = ['checksums.json', 'attachments'];
 const ALLOWED_TOP_LEVEL_ENTRIES = new Set([
   ...REQUIRED_DIR_ENTRIES,
   ...OPTIONAL_DIR_ENTRIES,
@@ -405,7 +435,7 @@ function validateContainerEntryMetadata(entry) {
     }
     throw new Error(`container includes unsupported top-level entry: ${topLevel}`);
   }
-  if ((topLevel === 'signatures' || topLevel === 'attachments') && normalizedName === topLevel) {
+  if (topLevel === 'attachments' && normalizedName === topLevel) {
     throw new Error(`container directory entry is not supported: ${name}`);
   }
   if (method !== 0 && method !== 8) {
@@ -558,7 +588,7 @@ function readLayout(absPath) {
         if (fs.statSync(full).isFile()) {
           map[f] = fs.readFileSync(full);
         } else {
-          // subdirectory like signatures/ — record its presence but not contents here
+          // Optional subdirectories are recorded without becoming payloads.
           map[f] = null;
         }
       }
@@ -570,7 +600,7 @@ function readLayout(absPath) {
     containerBytes = fs.readFileSync(absPath);
     entries = listZipEntriesFromBuffer(containerBytes);
     for (const e of entries) {
-      // We only need the well-known entries; signatures/ attachments/ etc.
+      // We only need the well-known entries and optional attachments.
       // are passed through unchanged by the loader but not parsed here.
       if (
         e.name === 'mimetype' ||
@@ -732,6 +762,32 @@ function parsePayloadEntry(name, bytes, opts = {}) {
   return parsed;
 }
 
+function assertDecryptedPayloadValid(payload, manifest) {
+  const validators = loadSchemas();
+  if (!validators) {
+    const error = new Error(
+      'Decrypted payload schema validation is unavailable.',
+    );
+    error.code = 'KDNA_PAYLOAD_SCHEMA_UNAVAILABLE';
+    throw error;
+  }
+  const isBundleProfile =
+    manifest.compatibility?.profile === 'kdna.payload.bundle' ||
+    manifest.asset_type === 'bundle';
+  const validator = isBundleProfile
+    ? validators.bundlePayload
+    : validators.payload;
+  if (validator(payload)) return payload;
+  const details = (validator.errors || [])
+    .map((entry) => `${entry.instancePath || '<root>'} ${entry.message}`)
+    .join('; ');
+  const error = new Error(
+    `Decrypted payload failed its declared schema${details ? `: ${details}` : '.'}`,
+  );
+  error.code = 'KDNA_PAYLOAD_INVALID';
+  throw error;
+}
+
 // ─── inspect ───────────────────────────────────────────────────────────
 
 /**
@@ -754,7 +810,6 @@ function buildInspectOutput(container) {
     ...assessLoaderCompatibility(m),
     load_contract_default_profile: m.load_contract ? m.load_contract.default_profile : null,
   };
-  if (m.signatures !== undefined) out.signature_count = Array.isArray(m.signatures) ? m.signatures.length : 0;
   if (container.map['checksums.json']) out.checksums_present = true;
   return out;
 }
@@ -1322,7 +1377,9 @@ function inputFingerprint(inputPath, layout, opts = {}) {
   ) ? opts.entitlement.status : null;
 
   return {
-    has_password_input: opts.hasPassword === true,
+    has_password_input:
+      opts.hasPassword === true ||
+      (typeof opts.password === 'string' && opts.password.length > 0),
     entitlement_input: entitlementInput,
     source_fingerprint: computeSourceFingerprint(inputPath, layout),
   };
@@ -1675,18 +1732,19 @@ function planLoad(inputPath, opts = {}) {
     }
 
     if (plan.entitlement_profile === 'password') {
-      if (opts.password || opts.hasPassword === true) {
-        if (opts.hasPassword === true && !opts.password) {
-          plan.issues.push(buildLoadPlanIssue(
-            'KDNA_AUTH_PASSWORD_DIAGNOSTIC',
-            'info',
-            'hasPassword is a diagnostic credential-presence signal only; it does not verify the password.',
-          ));
-        }
-        plan.state = 'ready';
-        plan.required_action = 'load';
-        plan.can_load_now = true;
-        plan.projection_policy = 'minimal';
+      if (
+        opts.hasPassword === true ||
+        (typeof opts.password === 'string' && opts.password.length > 0)
+      ) {
+        plan.state = 'needs_password';
+        plan.required_action = 'enter_password';
+        plan.can_load_now = false;
+        plan.projection_policy = 'none';
+        plan.issues.push(buildLoadPlanIssue(
+          'KDNA_AUTH_PASSWORD_UNVERIFIED',
+          'blocking',
+          'A password was provided but has not been verified. Only an authorized load may verify it by decrypting the protected payload.',
+        ));
       } else {
         plan.state = 'needs_password';
         plan.required_action = 'enter_password';
@@ -1958,10 +2016,10 @@ function renderPromptItem(item) {
   if (item.type === 'axiom_applicability' && item.one_sentence) {
     const parts = [item.one_sentence];
     if (Array.isArray(item.applies_when) && item.applies_when.length) {
-      parts.push(`applies when: ${item.applies_when.slice(0, 2).join('; ')}`);
+      parts.push(`applies when: ${item.applies_when.join('; ')}`);
     }
     if (Array.isArray(item.does_not_apply_when) && item.does_not_apply_when.length) {
-      parts.push(`does not apply when: ${item.does_not_apply_when.slice(0, 2).join('; ')}`);
+      parts.push(`does not apply when: ${item.does_not_apply_when.join('; ')}`);
     }
     if (item.failure_risk) parts.push(`failure risk: ${item.failure_risk}`);
     return parts.join(' — ');
@@ -2035,7 +2093,13 @@ function loadAuthorized(inputPath, opts = {}) {
   const inputKind = typeof inputPath === 'string' ? 'packaged_file' : 'packaged_bytes';
   const inputSnapshot = snapshotPackagedInput(inputPath);
   const plan = planLoad(inputSnapshot, opts);
-  if (plan.can_load_now !== true) {
+  const loadMayVerifyPassword =
+    typeof opts.password === 'string' &&
+    opts.password.length > 0 &&
+    plan.state === 'needs_password' &&
+    Array.isArray(plan.issues) &&
+    plan.issues.some((issue) => issue.code === 'KDNA_AUTH_PASSWORD_UNVERIFIED');
+  if (plan.can_load_now !== true && !loadMayVerifyPassword) {
     const issueCodes = Array.isArray(plan.issues)
       ? plan.issues.map((issue) => issue.code).filter(Boolean)
       : [];
@@ -2226,7 +2290,11 @@ function normalizeCompactAxiom(axiom) {
   if (!axiom || typeof axiom !== 'object') return null;
   const statement = axiom.statement || axiom.one_sentence || axiom.full_statement || axiom.id || null;
   if (!statement) return null;
-  const oneSentence = (axiom.one_sentence && !String(axiom.one_sentence).startsWith('<TBD')) ? axiom.one_sentence : (typeof axiom.full_statement === 'string' && axiom.full_statement.length > 0 ? axiom.full_statement.substring(0, 120) + (axiom.full_statement.length > 120 ? '…' : '') : statement);
+  const oneSentence = (axiom.one_sentence && !String(axiom.one_sentence).startsWith('<TBD'))
+    ? axiom.one_sentence
+    : (typeof axiom.full_statement === 'string' && axiom.full_statement.length > 0
+      ? axiom.full_statement
+      : statement);
   return {
     type: 'axiom_applicability',
     id: axiom.id || null,
@@ -2260,12 +2328,120 @@ function hasCompactPromptContent(content) {
       hasStandardJudgmentRoleContent(content.judgment_role) ||
       (Array.isArray(content.axioms) && content.axioms.length > 0) ||
       (Array.isArray(content.boundaries) && content.boundaries.length > 0) ||
+      (Array.isArray(content.core_structure) && content.core_structure.length > 0) ||
       (Array.isArray(content.self_checks) && content.self_checks.length > 0) ||
       (Array.isArray(content.failure_modes) && content.failure_modes.length > 0) ||
       (Array.isArray(content.patterns) && content.patterns.length > 0)
   );
 }
 
+const COMPACT_PROJECTED_CORE_FIELDS = new Set([
+  'highest_question',
+  'worldview',
+  'value_order',
+  'judgment_role',
+  'axioms',
+  'boundaries',
+  'core_structure',
+]);
+const COMPACT_PROJECTED_REASONING_FIELDS = new Set(['self_check', 'failure_modes']);
+const COMPACT_PROJECTED_AXIOM_FIELDS = new Set([
+  'id',
+  'statement',
+  'one_sentence',
+  'applies_when',
+  'does_not_apply_when',
+  'failure_risk',
+]);
+const COMPACT_NON_CONTENT_FIELDS = new Set(['profile', 'profile_version']);
+
+function escapeJsonPointerToken(value) {
+  return String(value).replaceAll('~', '~0').replaceAll('/', '~1');
+}
+
+function omissionCount(value) {
+  if (value === undefined || value === null) return 0;
+  if (Array.isArray(value)) return value.length;
+  if (typeof value === 'string') return value.trim() ? 1 : 0;
+  if (typeof value === 'object') return Object.keys(value).length > 0 ? 1 : 0;
+  return 1;
+}
+
+function addOmittedValue(entries, pointer, value) {
+  if (value && typeof value === 'object' && !Array.isArray(value)) {
+    for (const key of Object.keys(value).sort()) {
+      addOmittedValue(
+        entries,
+        `${pointer}/${escapeJsonPointerToken(key)}`,
+        value[key],
+      );
+    }
+    return;
+  }
+  const count = omissionCount(value);
+  if (count > 0) entries.push({ path: pointer, count });
+}
+
+function addOmittedAxiomFields(entries, axioms) {
+  const counts = new Map();
+  for (const axiom of Array.isArray(axioms) ? axioms : []) {
+    if (!axiom || typeof axiom !== 'object' || Array.isArray(axiom)) continue;
+    for (const key of Object.keys(axiom).sort()) {
+      if (COMPACT_PROJECTED_AXIOM_FIELDS.has(key)) continue;
+      const count = omissionCount(axiom[key]);
+      if (count === 0) continue;
+      const path = `/core/axioms/*/${escapeJsonPointerToken(key)}`;
+      counts.set(path, (counts.get(path) || 0) + count);
+    }
+  }
+  for (const path of [...counts.keys()].sort()) {
+    entries.push({ path, count: counts.get(path) });
+  }
+}
+
+function buildCompactProjectionReport(payload) {
+  const entries = [];
+  const core = payload && typeof payload.core === 'object' && !Array.isArray(payload.core)
+    ? payload.core
+    : {};
+  const reasoning = payload && typeof payload.reasoning === 'object' && !Array.isArray(payload.reasoning)
+    ? payload.reasoning
+    : {};
+
+  for (const key of Object.keys(core).sort()) {
+    if (!COMPACT_PROJECTED_CORE_FIELDS.has(key)) {
+      addOmittedValue(entries, `/core/${escapeJsonPointerToken(key)}`, core[key]);
+    }
+  }
+  addOmittedAxiomFields(entries, core.axioms);
+
+  for (const key of Object.keys(reasoning).sort()) {
+    if (!COMPACT_PROJECTED_REASONING_FIELDS.has(key)) {
+      addOmittedValue(entries, `/reasoning/${escapeJsonPointerToken(key)}`, reasoning[key]);
+    }
+  }
+
+  for (const key of Object.keys(payload || {}).sort()) {
+    if (
+      COMPACT_NON_CONTENT_FIELDS.has(key) ||
+      key === 'core' ||
+      key === 'patterns' ||
+      key === 'reasoning'
+    ) {
+      continue;
+    }
+    addOmittedValue(entries, `/${escapeJsonPointerToken(key)}`, payload[key]);
+  }
+
+  entries.sort((left, right) => left.path.localeCompare(right.path));
+  const omittedTotal = entries.reduce((total, entry) => total + entry.count, 0);
+  return {
+    status: omittedTotal > 0 ? 'partial' : 'complete',
+    omitted: entries,
+    omitted_total: omittedTotal,
+  };
+}
+
 function loadAssetUnsafe(inputPath, opts = {}) {
   const layout = readInputLayout(inputPath);
   const m = layout.manifest;
@@ -2284,6 +2460,7 @@ function loadAssetUnsafe(inputPath, opts = {}) {
     // B4: Attempt decryption when password or decrypt hook is available.
     if (opts.decryptEntry) {
       // Consumer-provided decrypt hook (e.g., licensed entry key)
+      let decryptedBuf;
       try {
         const decrypted = opts.decryptEntry({
           asset: { entries: layout.map, manifest: m },
@@ -2291,18 +2468,27 @@ function loadAssetUnsafe(inputPath, opts = {}) {
           entryName: 'payload.kdnab',
           ciphertext: layout.map['payload.kdnab'],
         });
-        const decryptedBuf = typeof decrypted === 'string'
+        decryptedBuf = typeof decrypted === 'string'
           ? Buffer.from(decrypted, 'utf8')
           : Buffer.from(decrypted);
-        payload = parsePayloadEntry('payload.kdnab', decryptedBuf);
       } catch (e) {
         const err = new Error(`Decryption failed: ${e.message}`);
         err.code = e.code || 'KDNA_DECRYPT_FAILED';
         throw err;
       }
+      try {
+        payload = assertDecryptedPayloadValid(
+          parsePayloadEntry('payload.kdnab', decryptedBuf),
+          m,
+        );
+      } catch (error) {
+        if (!error.code) error.code = 'KDNA_PAYLOAD_INVALID';
+        throw error;
+      }
     } else if (opts.password) {
       // Password-based decryption via kdna.encryption.password*
       // profiles. Detects Argon2id vs scrypt from the envelope profile.
+      let decryptedBuf;
       try {
         const {
           decryptProtectedEntry,
@@ -2316,17 +2502,25 @@ function loadAssetUnsafe(inputPath, opts = {}) {
         const decryptFn = (envelope.profile === PASSWORD_PROTECTED_SCRYPT_PROFILE)
           ? decryptProtectedEntryScrypt
           : decryptProtectedEntry;
-        const decryptedBuf = decryptFn(encryptedEnvelope, {
+        decryptedBuf = decryptFn(encryptedEnvelope, {
           entryName: 'payload.kdnab',
           manifest: m,
           password: opts.password,
         });
-        payload = parsePayloadEntry('payload.kdnab', decryptedBuf);
       } catch (e) {
         const err = new Error(`Decryption failed with provided password: ${e.message}`);
         err.code = 'KDNA_DECRYPT_FAILED';
         throw err;
       }
+      try {
+        payload = assertDecryptedPayloadValid(
+          parsePayloadEntry('payload.kdnab', decryptedBuf),
+          m,
+        );
+      } catch (error) {
+        if (!error.code) error.code = 'KDNA_PAYLOAD_INVALID';
+        throw error;
+      }
     } else {
       const isExternal = payload.profile === EXTERNAL_ENVELOPE_PROFILE;
       const err = new Error(
@@ -2408,6 +2602,32 @@ function loadAssetUnsafe(inputPath, opts = {}) {
         ))
         : []
     );
+    const projectCoreStructure = (items) => (
+      Array.isArray(items)
+        ? items.map((relation) => {
+            if (
+              !relation ||
+              typeof relation !== 'object' ||
+              Array.isArray(relation)
+            ) {
+              return null;
+            }
+            const projected = {};
+            for (const key of [
+              'from',
+              'to',
+              'via',
+              'applies_when',
+              'does_not_apply_when',
+            ]) {
+              if (relation[key] !== undefined) {
+                projected[key] = globalThis.structuredClone(relation[key]);
+              }
+            }
+            return projected;
+          }).filter(Boolean)
+        : []
+    );
     result.content = {
       highest_question: core.highest_question || null,
       // These scoped domain-level values are already validated by the payload
@@ -2423,13 +2643,17 @@ function loadAssetUnsafe(inputPath, opts = {}) {
           : null,
       axioms: (core.axioms || []).map(normalizeCompactAxiom).filter(Boolean),
       boundaries: normalizeList(core.boundaries),
+      // Relations are already part of the public Payload. Preserve order and
+      // the closed public relation fields, never arbitrary authoring state.
+      core_structure: projectCoreStructure(core.core_structure),
       // Payload uses the singular field name while Runtime Capsule uses the
       // plural collection name. Preserve every validated item and its shape;
       // strings remain strings and structured questions remain objects.
       self_checks: preserveDeclaredList(payload.reasoning && payload.reasoning.self_check),
       failure_modes: normalizeList(payload.reasoning && payload.reasoning.failure_modes),
-      patterns: normalizeList(payload.patterns).slice(0, 3),
+      patterns: normalizeList(payload.patterns),
     };
+    result.projection_report = buildCompactProjectionReport(payload);
     if (m.load_contract && m.load_contract.profiles && m.load_contract.profiles.compact && m.load_contract.profiles.compact.max_tokens_hint) {
       result.max_tokens_hint = m.load_contract.profiles.compact.max_tokens_hint;
     }
@@ -2547,6 +2771,14 @@ function loadAssetUnsafe(inputPath, opts = {}) {
     text += 'Asset ID: ' + (result.asset_id || 'unknown') + '\n';
     text += 'Profile: ' + result.profile + '\n';
     text += 'Safety boundary: KDNA content is subordinate to platform, system, and developer instructions.\n';
+    if (result.projection_report) {
+      text += `Projection completeness: ${result.projection_report.status}\n`;
+      if (result.projection_report.omitted.length > 0) {
+        text += 'Omitted payload paths: ' + result.projection_report.omitted
+          .map((entry) => `${entry.path} (${entry.count})`)
+          .join('; ') + '\n';
+      }
+    }
     if (result.max_tokens_hint) text += 'Max tokens hint: ' + result.max_tokens_hint + '\n';
     if (c.highest_question) text += 'Highest question:\n' + c.highest_question + '\n';
     if (hasStandardJudgmentRoleContent(c.judgment_role)) {
@@ -2570,6 +2802,17 @@ function loadAssetUnsafe(inputPath, opts = {}) {
     }
     if (c.axioms && c.axioms.length) text += 'Axioms:\n' + c.axioms.map((a) => '- ' + renderPromptItem(a)).join('\n') + '\n';
     if (c.boundaries && c.boundaries.length) text += 'Boundaries:\n' + c.boundaries.map((b) => '- ' + renderPromptItem(b)).join('\n') + '\n';
+    if (c.core_structure && c.core_structure.length) {
+      text += 'Judgment relations:\n' + c.core_structure.map((relation) => {
+        if (typeof relation === 'string') return '- ' + sanitizePrompt(relation);
+        if (!relation || typeof relation !== 'object' || Array.isArray(relation)) {
+          return '- (unrendered relation)';
+        }
+        const from = sanitizePrompt(relation.from || 'unknown');
+        const to = sanitizePrompt(relation.to || 'unknown');
+        return `- ${from} --${sanitizePrompt(relation.via || 'relates_to')}--> ${to}`;
+      }).join('\n') + '\n';
+    }
     if (c.self_checks && c.self_checks.length) text += 'Self-checks:\n' + c.self_checks.map((s) => '- ' + renderPromptItem(s)).join('\n') + '\n';
     if (c.failure_modes && c.failure_modes.length) text += 'Failure modes:\n' + c.failure_modes.map((f) => '- ' + renderPromptItem(f)).join('\n') + '\n';
     if (c.patterns && c.patterns.length) text += 'Patterns:\n' + c.patterns.map((p) => '- ' + renderPromptItem(p)).join('\n') + '\n';
@@ -2610,8 +2853,6 @@ function wrapAsCapsule(result, layout, profile, opts) {
 function buildRuntimeCapsuleProjection(loadResult, layout, profile, opts = {}) {
   const m = layout.manifest;
   const val = opts._validation || {};
-  const pubkey = (m.creator && m.creator.pubkey) || null;
-  const sigVerified = val.signature_valid === true;
   const runtimeCapsule = require('../runtime-capsule');
   const digests = runtimeCapsule.computeDigestEvidence(opts._runtimeAssetBytes, {
     expectedDigests: opts.expectedDigests,
@@ -2620,9 +2861,7 @@ function buildRuntimeCapsuleProjection(loadResult, layout, profile, opts = {}) {
     projection: loadResult,
     manifest: m,
     digests,
-    signature: pubkey
-      ? { state: sigVerified ? 'verified' : 'not_checked', issuer: pubkey }
-      : { state: 'absent' },
+    signature: { state: 'absent' },
     inputKind: opts._runtimeInputKind,
     loadedAt: opts.loadedAt,
     schemaValid: val.schema_valid === true,

package/src/crypto-profile.js

@@ -278,6 +278,18 @@ function ensureArgon2id() {
   }
 }
 
+const MAX_ARGON2_MEMORY_KIB = 262144; // 256 MiB
+const MAX_ARGON2_ITERATIONS = 16;
+const MAX_ARGON2_PARALLELISM = 8;
+
+function boundedArgon2Param(value, name, max) {
+  if (value === undefined) return undefined;
+  if (!Number.isSafeInteger(value) || value < 1 || value > max) {
+    throw new Error(`unsupported Argon2id ${name}: must be an integer between 1 and ${max}`);
+  }
+  return value;
+}
+
 function derivePasswordKey(password, params = {}) {
   ensureArgon2id();
   const {
@@ -287,12 +299,15 @@ function derivePasswordKey(password, params = {}) {
     parallelism = 4,
   } = params;
   if (!salt) throw new Error('salt is required for Argon2id');
+  const boundedMemory = boundedArgon2Param(memory_kib, 'memory_kib', MAX_ARGON2_MEMORY_KIB);
+  const boundedIterations = boundedArgon2Param(iterations, 'iterations', MAX_ARGON2_ITERATIONS);
+  const boundedParallelism = boundedArgon2Param(parallelism, 'parallelism', MAX_ARGON2_PARALLELISM);
   const saltBuf = decodeBase64(salt, 'salt');
   const passwordBuf = toBuffer(password, 'password');
   const key = argon2id(passwordBuf, saltBuf, {
-    t: iterations,
-    m: memory_kib,
-    p: parallelism,
+    t: boundedIterations,
+    m: boundedMemory,
+    p: boundedParallelism,
     dkLen: 32,
   });
   return Buffer.from(key);

package/src/external-key-grant.js

@@ -7,11 +7,12 @@
  */
 
 const crypto = require('node:crypto');
-const path = require('node:path');
 const JsonSchema2020 = require('ajv/dist/2020');
 const addFormats = require('ajv-formats');
 const cbor = require('cbor-x');
 const { hkdfSha256, aesWrap, aesUnwrap } = require('./crypto-profile');
+const externalEnvelopeSchema = require('../schema/external-grant-envelope.schema.json');
+const externalKeyGrantSchema = require('../schema/external-key-grant.schema.json');
 
 const EXTERNAL_ENVELOPE_PROFILE = 'kdna.envelope.external-grant';
 const EXTERNAL_GRANT_PROFILE = 'kdna.grant.external-key';
@@ -21,15 +22,10 @@ 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 JsonSchema2020({ allErrors: true, strict: true });
 addFormats(ajv);
-const validateEnvelopeSchema = ajv.compile(
-  require(path.join(schemaRoot, 'external-grant-envelope.schema.json')),
-);
-const validateGrantSchema = ajv.compile(
-  require(path.join(schemaRoot, 'external-key-grant.schema.json')),
-);
+const validateEnvelopeSchema = ajv.compile(externalEnvelopeSchema);
+const validateGrantSchema = ajv.compile(externalKeyGrantSchema);
 
 const verifiedEntitlements = new WeakSet();
 

package/src/index.mjs

@@ -78,8 +78,6 @@ 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;

package/src/public-api.js

@@ -63,7 +63,6 @@ async function inspectKDNA(input, options = {}) {
     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 : [],
@@ -84,7 +83,6 @@ function inspectKDNASync(input, options = {}) {
     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 : [],
@@ -138,14 +136,6 @@ function verifyDigestSync(input, expectedDigest, options = {}) {
   return verifyAssetSync(input, { ...options, asset_digest: expectedDigest });
 }
 
-async function verifySignature(input, options = {}) {
-  return verifyAsset(input, { ...options, requireSignature: true });
-}
-
-function verifySignatureSync(input, options = {}) {
-  return verifyAssetSync(input, { ...options, requireSignature: true });
-}
-
 function scoreMatch(input, info) {
   const haystack = String(input || '').toLowerCase();
   const terms = [
@@ -211,8 +201,6 @@ module.exports = {
   verifyAssetSync,
   verifyDigest,
   verifyDigestSync,
-  verifySignature,
-  verifySignatureSync,
   matchDomain,
   matchDomainSync,
   composeKDNA,

package/src/runtime-capsule.js

@@ -475,7 +475,22 @@ function buildRuntimeCapsule({
   if (!['public', 'licensed', 'remote'].includes(runtimeAccess)) {
     fail('KDNA_RUNTIME_CAPSULE_BUILD_INVALID', `Unsupported Runtime access: ${runtimeAccess}.`);
   }
-  const signatureEvidence = signature || { state: 'absent' };
+  if (
+    signature !== undefined &&
+    (
+      !signature ||
+      typeof signature !== 'object' ||
+      Array.isArray(signature) ||
+      signature.state !== 'absent' ||
+      Object.keys(signature).some((key) => key !== 'state')
+    )
+  ) {
+    fail(
+      'KDNA_ASSET_SIGNATURE_UNSUPPORTED',
+      'Asset signatures are outside the current Preview contract.',
+    );
+  }
+  const signatureEvidence = { state: 'absent' };
 
   const capsule = {
     type: 'kdna.runtime-capsule',
@@ -502,6 +517,9 @@ function buildRuntimeCapsule({
       profile: projection.profile,
     },
   };
+  if (projection.projection_report !== undefined) {
+    capsule.trace.projection_report = globalThis.structuredClone(projection.projection_report);
+  }
   assertRuntimeCapsuleSuccess(capsule, 'KDNA_RUNTIME_CAPSULE_BUILD_INVALID');
   return capsule;
 }