@aikdna/kdna-core 0.17.0 → 0.19.0

package/src/index.mjs

@@ -10,10 +10,9 @@ export {
   formatContext,
 } from './loader.js';
 
-export { lintDomain } from './lint-pure.js';
-
 export {
   MIMETYPE,
+  KDNA_LOADER_VERSION,
   REQUIRED_DIR_ENTRIES,
   isKdnaSourceDir,
   detectContainerFormat,
@@ -23,12 +22,17 @@ export {
   buildChecksums,
   pack,
   unpack,
-  buildCapsule,
   FORBIDDEN_OUTPUT_TERMS,
   parseSemver,
   compareSemver,
   satisfies,
-} from './v1/index.js';
+} from './container/index.js';
+
+import loaderCompatibility from './loader-compatibility.js';
+export const STRICT_LOADER_VERSION = loaderCompatibility.STRICT_LOADER_VERSION;
+export const parseLoaderVersion = loaderCompatibility.parseLoaderVersion;
+export const compareLoaderVersions = loaderCompatibility.compareLoaderVersions;
+export const assessLoaderCompatibility = loaderCompatibility.assessLoaderCompatibility;
 
 import runtimeApi from './runtime-api.js';
 export const planLoad = runtimeApi.planLoad;
@@ -40,30 +44,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 runtimeCapsule from './runtime-capsule.js';
+import runtimeContract from './runtime-contract.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 = runtimeCapsule.DIGEST_PROFILE;
+export const DIGEST_PROFILE_VERSION = runtimeCapsule.DIGEST_PROFILE_VERSION;
+export const CAPSULE_DIGEST_PROFILE = runtimeCapsule.CAPSULE_DIGEST_PROFILE;
+export const CANONICALIZATION_PROFILE_VERSION = runtimeCapsule.CANONICALIZATION_PROFILE_VERSION;
+export const RUNTIME_CAPSULE_CONTRACT_VERSION = runtimeCapsule.RUNTIME_CAPSULE_CONTRACT_VERSION;
+export const BASIS = runtimeCapsule.BASIS;
+export const computeAssetDigest = runtimeCapsule.computeAssetDigest;
+export const computeRuntimeEntrySetDigest = runtimeCapsule.computeRuntimeEntrySetDigest;
+export const computeDigestEvidence = runtimeCapsule.computeDigestEvidence;
+export const canonicalizeJcs = runtimeCapsule.canonicalizeJcs;
+export const computeCapsuleDeliveryDigest = runtimeCapsule.computeCapsuleDeliveryDigest;
+export const buildRuntimeCapsule = runtimeCapsule.buildRuntimeCapsule;
+export const loadRuntimeCapsule = runtimeCapsule.loadRuntimeCapsule;
+
+export const KDNARuntimeContractError = runtimeContract.KDNARuntimeContractError;
+export const PLAN_DIGEST_PROFILE = runtimeContract.PLAN_DIGEST_PROFILE;
+export const PLAN_DIGEST_PROFILE_VERSION = runtimeContract.PLAN_DIGEST_PROFILE_VERSION;
+export const HOST_PROTOCOL = runtimeContract.HOST_PROTOCOL;
+export const HOST_PROTOCOL_VERSION = runtimeContract.HOST_PROTOCOL_VERSION;
+export const DEFAULT_CORE_CAPSULE_CONTRACT_VERSIONS =
+  runtimeContract.DEFAULT_CORE_CAPSULE_CONTRACT_VERSIONS;
+export const parseRuntimeContractJson = runtimeContract.parseRuntimeContractJson;
+export const computeConsumptionPlanDigest = runtimeContract.computeConsumptionPlanDigest;
+export const buildConsumptionPlan = runtimeContract.buildConsumptionPlan;
+export const validateConsumptionPlan = runtimeContract.validateConsumptionPlan;
+export const negotiateRuntimePair = runtimeContract.negotiateRuntimePair;
+export const buildAgentHostRequest = runtimeContract.buildAgentHostRequest;
+export const validateAgentHostRequest = runtimeContract.validateAgentHostRequest;
+export const validateAgentHostReceipt = runtimeContract.validateAgentHostReceipt;
+export const deriveBudgetEvidence = runtimeContract.deriveBudgetEvidence;
+export const buildPreHostBudgetBlockedTrace =
+  runtimeContract.buildPreHostBudgetBlockedTrace;
+export const validatePreHostBudgetBlockedTrace =
+  runtimeContract.validatePreHostBudgetBlockedTrace;
+export const buildJudgmentTrace = runtimeContract.buildJudgmentTrace;
+export const validateJudgmentTrace = runtimeContract.validateJudgmentTrace;
 
 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,
+  PASSWORD_PROTECTED_PROFILE,
+  PASSWORD_PROTECTED_SCRYPT_PROFILE,
+  ENCRYPTION_PROFILE_VERSION,
+  ALG,
+  RFC_KDF,
+  RFC_KEY_WRAPPING,
+  PASSWORD_KDF,
+  SCRYPT_KDF,
+  deriveWrappingKey,
+  generateCEK,
+  wrapCEK,
+  unwrapCEK,
+  encryptLicensedEntry,
+  decryptLicensedEntry,
+  derivePasswordKey,
+  generateRecoveryCode,
+  decodeRecoveryCode,
+  encryptProtectedEntry,
+  decryptProtectedEntry,
+  createPasswordDecryptEntry,
+  createRecoveryDecryptEntry,
+  derivePasswordKeyScrypt,
+  encryptProtectedEntryScrypt,
+  decryptProtectedEntryScrypt,
+  createPasswordDecryptEntryScrypt,
+  createLicensedDecryptEntry,
+  hkdfSha256,
+  aesWrap,
+  aesUnwrap,
+} = cryptoProfile;
+
+export const {
+  EXTERNAL_ENVELOPE_PROFILE,
+  EXTERNAL_GRANT_PROFILE,
+  EXTERNAL_AAD_PROFILE,
+  DEVICE_KEK_PROFILE,
+  EXTERNAL_GRANT_CONTRACT_VERSION,
+  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/loader-compatibility.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const { version: KDNA_LOADER_VERSION } = require('../package.json');
+
+const STRICT_LOADER_VERSION = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)$/u;
+
+function parseLoaderVersion(value) {
+  if (typeof value !== 'string') return null;
+  const match = STRICT_LOADER_VERSION.exec(value);
+  return match ? Object.freeze(match.slice(1)) : null;
+}
+
+function compareNumericIdentifier(left, right) {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+
+function compareLoaderVersions(leftVersion, rightVersion) {
+  const left = parseLoaderVersion(leftVersion);
+  const right = parseLoaderVersion(rightVersion);
+  if (!left || !right) {
+    throw new TypeError('loader versions must use strict x.y.z SemVer without leading zeros');
+  }
+  for (let index = 0; index < 3; index += 1) {
+    const comparison = compareNumericIdentifier(left[index], right[index]);
+    if (comparison !== 0) return comparison;
+  }
+  return 0;
+}
+
+if (!parseLoaderVersion(KDNA_LOADER_VERSION)) {
+  throw new Error(`@aikdna/kdna-core package version is not a strict loader coordinate: ${KDNA_LOADER_VERSION}`);
+}
+
+function assessLoaderCompatibility(manifest) {
+  const requiredValue = manifest?.compatibility?.min_loader_version;
+  const required = parseLoaderVersion(requiredValue);
+  return Object.freeze({
+    loader_version: KDNA_LOADER_VERSION,
+    min_loader_version: typeof requiredValue === 'string' ? requiredValue : null,
+    loader_compatible: required
+      ? compareLoaderVersions(requiredValue, KDNA_LOADER_VERSION) <= 0
+      : null,
+  });
+}
+
+function loaderVersionUnsupportedMessage(requiredVersion) {
+  return `KDNA_LOADER_VERSION_UNSUPPORTED: asset requires loader ${requiredVersion}, current loader is ${KDNA_LOADER_VERSION}`;
+}
+
+module.exports = {
+  KDNA_LOADER_VERSION,
+  STRICT_LOADER_VERSION,
+  parseLoaderVersion,
+  compareLoaderVersions,
+  assessLoaderCompatibility,
+  loaderVersionUnsupportedMessage,
+};

package/src/loader.js

@@ -157,7 +157,7 @@ function detectOldFieldNames(obj, path = '', warnings = []) {
   for (const key of Object.keys(obj)) {
     if (FIELD_ALIASES[key]) {
       warnings.push(
-        `[KDNA LOADER] ${path}.${key}: field "${key}" is not in spec v0.4. Use "${FIELD_ALIASES[key]}" instead. See docs/authoring-guide.md §0.`,
+        `[KDNA LOADER] ${path}.${key}: field "${key}" is not in spec 0.4. Use "${FIELD_ALIASES[key]}" instead. See docs/authoring-guide.md §0.`,
       );
     }
     if (typeof obj[key] === 'object' && obj[key] !== null) {

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 container = require('./container');
+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 = container.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 = container.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 container.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 container.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/remote-runtime.d.ts

@@ -0,0 +1,13 @@
+import type { KDNARuntimeCapsule } from './types';
+
+/** A final packaged `.kdna` file path or its immutable packaged bytes. */
+export type KDNARemoteRuntimeInput = string | Uint8Array;
+
+/**
+ * Load one deployer-controlled `access: "remote"` asset for server-side
+ * projection. The function always returns a full JSON Runtime Capsule and
+ * accepts no caller policy options.
+ */
+export function loadRemoteRuntimeAsset(
+  input: KDNARemoteRuntimeInput,
+): KDNARuntimeCapsule;

package/src/remote-runtime.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const container = require('./container');
+
+/**
+ * Load one deployer-controlled `access: "remote"` packaged asset for a
+ * server-side projection Runtime.
+ *
+ * This API intentionally accepts no caller policy options. Physical control
+ * of the packaged remote asset is the deployment authorization boundary; the
+ * embedding server remains responsible for request authentication,
+ * entitlement checks, projection minimization, and audit policy.
+ */
+function loadRemoteRuntimeAsset(input) {
+  if (arguments.length !== 1) {
+    const error = new Error(
+      'loadRemoteRuntimeAsset accepts exactly one packaged asset input and no caller policy options.',
+    );
+    error.code = 'KDNA_REMOTE_RUNTIME_OPTIONS_FORBIDDEN';
+    throw error;
+  }
+  return container.loadRemoteRuntimeAssetForServer(input);
+}
+
+module.exports = {
+  loadRemoteRuntimeAsset,
+};

package/src/remote-runtime.mjs

@@ -0,0 +1,3 @@
+import remoteRuntime from './remote-runtime.js';
+
+export const loadRemoteRuntimeAsset = remoteRuntime.loadRemoteRuntimeAsset;

package/src/runtime-api.js

@@ -2,12 +2,12 @@
 
 const fs = require('node:fs');
 const path = require('node:path');
-const v1 = require('./v1');
+const container = require('./container');
 
 function invalidDirectoryPlan(inputPath) {
   const resolved = path.resolve(inputPath);
   return {
-    kdna_version: null,
+    format_version: null,
     asset: { asset_id: null, asset_uid: null, title: null, version: null, judgment_version: null },
     access: null,
     access_alias: null,
@@ -64,23 +64,22 @@ function guardResolver(options = {}) {
 
 function planLoad(inputPath, options = {}) {
   if (isDirectory(inputPath)) return invalidDirectoryPlan(inputPath);
-  return v1.planLoad(inputPath, guardResolver(options));
+  return container.planLoad(inputPath, guardResolver(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;
   }
-  return v1.loadAuthorized(inputPath, guardResolver(options));
+  // container.loadAuthorized snapshots packaged paths once and uses that same Buffer
+  // for its LoadPlan, authorization decision, and Runtime Capsule projection.
+  return container.loadAuthorized(inputPath, guardResolver(options));
 }
 
 module.exports = {