@aikdna/kdna-core 0.21.0 → 0.22.0

package/src/runtime-capsule.js

@@ -8,6 +8,10 @@ const addFormats = require('ajv-formats');
 
 const { createKdnaAssetReader } = require('./asset-reader');
 const container = require('./container');
+const {
+  KDSIG_PROFILE,
+  KDSIG_PROFILE_VERSION,
+} = require('./signature');
 const digestEvidenceSchema = require('../schema/digest-evidence.schema.json');
 const runtimeCapsuleSchema = require('../schema/runtime-capsule.schema.json');
 
@@ -433,6 +437,82 @@ function assertSuccessfulDigestEvidence(digests) {
   }
 }
 
+const SIGNATURE_EVIDENCE_FIELDS = Object.freeze({
+  absent: ['state'],
+  verified: ['state', 'profile', 'profile_version', 'key_fingerprint', 'content_digest'],
+});
+
+/**
+ * Normalize Runtime Capsule signature evidence (RFC-0021 M1). Unsigned assets
+ * report `{ state: 'absent' }`; signed assets report the verified kdsig.ed25519
+ * evidence. Any other shape fails closed — signatures never downgrade to
+ * "absent" and unknown profiles are never collapsed into known ones.
+ */
+function normalizeSignatureEvidence(signature) {
+  if (signature === undefined) return { state: 'absent' };
+  if (!signature || typeof signature !== 'object' || Array.isArray(signature)) {
+    fail(
+      'KDNA_RUNTIME_CAPSULE_BUILD_INVALID',
+      'Runtime Capsule signature evidence must be an object.',
+    );
+  }
+  if (signature.state === 'absent') {
+    const extra = Object.keys(signature).filter((key) => key !== 'state');
+    if (extra.length) {
+      fail(
+        'KDNA_RUNTIME_CAPSULE_BUILD_INVALID',
+        'Absent signature evidence must not carry extra fields.',
+      );
+    }
+    return { state: 'absent' };
+  }
+  if (signature.state === 'verified') {
+    const keys = Object.keys(signature).sort();
+    const expected = [...SIGNATURE_EVIDENCE_FIELDS.verified].sort();
+    if (keys.join(',') !== expected.join(',')) {
+      fail(
+        'KDNA_RUNTIME_CAPSULE_BUILD_INVALID',
+        `Verified signature evidence must carry exactly: ${SIGNATURE_EVIDENCE_FIELDS.verified.join(', ')}.`,
+      );
+    }
+    if (signature.profile !== KDSIG_PROFILE) {
+      fail(
+        'KDNA_ASSET_SIGNATURE_UNSUPPORTED',
+        `Signature profile ${JSON.stringify(signature.profile)} is not supported (supported: ${KDSIG_PROFILE}).`,
+      );
+    }
+    if (signature.profile_version !== KDSIG_PROFILE_VERSION) {
+      fail(
+        'KDNA_ASSET_SIGNATURE_UNSUPPORTED',
+        `Signature profile_version ${JSON.stringify(signature.profile_version)} is not supported (supported: ${KDSIG_PROFILE_VERSION}).`,
+      );
+    }
+    if (!SHA256_RE.test(signature.key_fingerprint || '')) {
+      fail(
+        'KDNA_RUNTIME_CAPSULE_BUILD_INVALID',
+        'Verified signature evidence requires a sha256 key_fingerprint.',
+      );
+    }
+    if (!SHA256_RE.test(signature.content_digest || '')) {
+      fail(
+        'KDNA_RUNTIME_CAPSULE_BUILD_INVALID',
+        'Verified signature evidence requires a sha256 content_digest.',
+      );
+    }
+    return {
+      state: 'verified',
+      profile: signature.profile,
+      profile_version: signature.profile_version,
+      key_fingerprint: signature.key_fingerprint,
+      content_digest: signature.content_digest,
+    };
+  }
+  fail(
+    'KDNA_ASSET_SIGNATURE_UNSUPPORTED',
+    `Signature state ${JSON.stringify(signature.state)} is not supported (supported: absent, verified).`,
+  );
+}
+
 function normalizeRuntimeAccess(access) {
   return access === undefined ? 'public' : access;
 }
@@ -475,22 +555,7 @@ function buildRuntimeCapsule({
   if (!['public', 'licensed', 'remote'].includes(runtimeAccess)) {
     fail('KDNA_RUNTIME_CAPSULE_BUILD_INVALID', `Unsupported Runtime access: ${runtimeAccess}.`);
   }
-  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 signatureEvidence = normalizeSignatureEvidence(signature);
 
   const capsule = {
     type: 'kdna.runtime-capsule',

package/src/signature.js

@@ -0,0 +1,320 @@
+/**
+ * KDNA asset signatures — RFC-0021 M1 (`kdsig.ed25519`).
+ *
+ * A `.kdna` container carries an optional top-level `signature.kdsig` entry:
+ * a JSON signature bundle whose Ed25519 signature covers a deterministic
+ * signing payload derived from the asset's canonical content digest
+ * (docs/CANONICALIZATION.md). Verification is offline and fail-closed: any
+ * malformed, unsupported, or unverifiable bundle rejects the asset.
+ *
+ * A signature proves integrity and provenance only. It never proves
+ * expertise, truthfulness, safety, or fitness for purpose.
+ */
+
+'use strict';
+
+const crypto = require('crypto');
+
+const KDSIG_PROFILE = 'kdsig.ed25519';
+const KDSIG_PROFILE_VERSION = '0.1.0';
+const KDSIG_ALGORITHM = 'ed25519';
+const SIGNATURE_ENTRY_NAME = 'signature.kdsig';
+
+const RAW_PUBLIC_KEY_HEX_LENGTH = 64;
+const RAW_SIGNATURE_HEX_LENGTH = 128;
+const SHA256_HEX_LENGTH = 64;
+
+// RFC 8410 DER prefixes for raw Ed25519 key material.
+const PKCS8_ED25519_PREFIX = Buffer.from('302e020100300506032b657004220420', 'hex');
+const SPKI_ED25519_PREFIX = Buffer.from('302a300506032b6570032100', 'hex');
+
+const BUNDLE_FIELDS = Object.freeze([
+  'algorithm',
+  'content_digest',
+  'profile',
+  'profile_version',
+  'public_key',
+  'signature',
+]);
+
+function sha256Hex(buf) {
+  return crypto.createHash('sha256').update(buf).digest('hex');
+}
+
+function signatureError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function isLowercaseHex(value, length) {
+  return typeof value === 'string' && value.length === length && /^[0-9a-f]+$/.test(value);
+}
+
+function assertContentDigestShape(value) {
+  if (
+    typeof value !== 'string'
+    || !value.startsWith('sha256:')
+    || !isLowercaseHex(value.slice('sha256:'.length), SHA256_HEX_LENGTH)
+  ) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `signature bundle content_digest must be "sha256:<64 lowercase hex>", got ${JSON.stringify(value)}`,
+    );
+  }
+}
+
+/**
+ * Build the exact bytes that Ed25519 signs. The payload is domain-separated by
+ * the profile coordinate and binds the asset's canonical content digest, so a
+ * signature can never be replayed across profiles, versions, or assets.
+ */
+function buildSigningPayload(contentDigest) {
+  assertContentDigestShape(contentDigest);
+  return Buffer.from(`${KDSIG_PROFILE}:${KDSIG_PROFILE_VERSION}:${contentDigest}`, 'utf8');
+}
+
+function privateKeyObjectFromSeed(seedHex) {
+  if (!isLowercaseHex(seedHex, RAW_PUBLIC_KEY_HEX_LENGTH)) {
+    throw signatureError(
+      'KDNA_SIGNATURE_KEY_INVALID',
+      'Ed25519 private key must be a 32-byte seed encoded as 64 lowercase hex characters',
+    );
+  }
+  const der = Buffer.concat([PKCS8_ED25519_PREFIX, Buffer.from(seedHex, 'hex')]);
+  try {
+    return crypto.createPrivateKey({ key: der, format: 'der', type: 'pkcs8' });
+  } catch (e) {
+    throw signatureError('KDNA_SIGNATURE_KEY_INVALID', `invalid Ed25519 private key: ${e.message}`);
+  }
+}
+
+function publicKeyObjectFromRaw(publicKeyHex) {
+  if (!isLowercaseHex(publicKeyHex, RAW_PUBLIC_KEY_HEX_LENGTH)) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      'signature bundle public_key must be a 32-byte Ed25519 key encoded as 64 lowercase hex characters',
+    );
+  }
+  const der = Buffer.concat([SPKI_ED25519_PREFIX, Buffer.from(publicKeyHex, 'hex')]);
+  try {
+    return crypto.createPublicKey({ key: der, format: 'der', type: 'spki' });
+  } catch (e) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `signature bundle public_key is not a valid Ed25519 key: ${e.message}`,
+    );
+  }
+}
+
+function rawPublicKeyHexFromObject(keyObject) {
+  const spki = keyObject.export({ format: 'der', type: 'spki' });
+  return spki.subarray(SPKI_ED25519_PREFIX.length).toString('hex');
+}
+
+/**
+ * Generate a new Ed25519 signing key pair. The private key is returned as the
+ * raw 32-byte seed in lowercase hex; custody is the signer's responsibility.
+ */
+function generateSigningKeyPair() {
+  const { privateKey, publicKey } = crypto.generateKeyPairSync('ed25519');
+  const pkcs8 = privateKey.export({ format: 'der', type: 'pkcs8' });
+  const seedHex = pkcs8.subarray(PKCS8_ED25519_PREFIX.length).toString('hex');
+  return {
+    algorithm: KDSIG_ALGORITHM,
+    private_key: seedHex,
+    public_key: rawPublicKeyHexFromObject(publicKey),
+  };
+}
+
+/**
+ * Fingerprint of a raw Ed25519 public key: sha256 over the 32 key bytes.
+ */
+function keyFingerprint(publicKeyHex) {
+  if (!isLowercaseHex(publicKeyHex, RAW_PUBLIC_KEY_HEX_LENGTH)) {
+    throw signatureError(
+      'KDNA_SIGNATURE_KEY_INVALID',
+      'keyFingerprint expects a 32-byte Ed25519 public key encoded as 64 lowercase hex characters',
+    );
+  }
+  return `sha256:${sha256Hex(Buffer.from(publicKeyHex, 'hex'))}`;
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  if (value && typeof value === 'object') {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+/**
+ * Serialize a signature bundle to its canonical wire bytes (sorted keys, no
+ * insignificant whitespace). Verification accepts any JSON encoding of the
+ * same fields; canonical bytes are what signers and vectors pin.
+ */
+function serializeSignatureBundle(bundle) {
+  return Buffer.from(`${stableStringify(bundle)}\n`, 'utf8');
+}
+
+function parseSignatureBundle(bytes) {
+  let text;
+  try {
+    text = Buffer.isBuffer(bytes) ? bytes.toString('utf8') : String(bytes);
+  } catch (e) {
+    throw signatureError('KDNA_INTEGRITY_SIGNATURE_FAILED', `signature bundle is not UTF-8: ${e.message}`);
+  }
+  let bundle;
+  try {
+    bundle = JSON.parse(text);
+  } catch (e) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `signature.kdsig is not valid JSON: ${e.message}`,
+    );
+  }
+  if (!bundle || typeof bundle !== 'object' || Array.isArray(bundle)) {
+    throw signatureError('KDNA_INTEGRITY_SIGNATURE_FAILED', 'signature bundle must be a JSON object');
+  }
+  for (const field of BUNDLE_FIELDS) {
+    if (typeof bundle[field] !== 'string') {
+      throw signatureError(
+        'KDNA_INTEGRITY_SIGNATURE_FAILED',
+        `signature bundle is missing required string field: ${field}`,
+      );
+    }
+  }
+  const extra = Object.keys(bundle).filter((key) => !BUNDLE_FIELDS.includes(key));
+  if (extra.length) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `signature bundle carries unsupported fields: ${extra.sort().join(', ')}`,
+    );
+  }
+  if (bundle.profile !== KDSIG_PROFILE) {
+    throw signatureError(
+      'KDNA_SIGNATURE_PROFILE_UNSUPPORTED',
+      `signature bundle profile ${JSON.stringify(bundle.profile)} is not supported (supported: ${KDSIG_PROFILE})`,
+    );
+  }
+  if (bundle.profile_version !== KDSIG_PROFILE_VERSION) {
+    throw signatureError(
+      'KDNA_SIGNATURE_VERSION_UNSUPPORTED',
+      `signature bundle profile_version ${JSON.stringify(bundle.profile_version)} is not supported (supported: ${KDSIG_PROFILE_VERSION})`,
+    );
+  }
+  if (bundle.algorithm !== KDSIG_ALGORITHM) {
+    throw signatureError(
+      'KDNA_SIGNATURE_PROFILE_UNSUPPORTED',
+      `signature bundle algorithm ${JSON.stringify(bundle.algorithm)} is not supported (supported: ${KDSIG_ALGORITHM})`,
+    );
+  }
+  assertContentDigestShape(bundle.content_digest);
+  if (!isLowercaseHex(bundle.public_key, RAW_PUBLIC_KEY_HEX_LENGTH)) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      'signature bundle public_key must be 64 lowercase hex characters',
+    );
+  }
+  if (!isLowercaseHex(bundle.signature, RAW_SIGNATURE_HEX_LENGTH)) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      'signature bundle signature must be 128 lowercase hex characters',
+    );
+  }
+  return {
+    profile: bundle.profile,
+    profile_version: bundle.profile_version,
+    algorithm: bundle.algorithm,
+    content_digest: bundle.content_digest,
+    public_key: bundle.public_key,
+    signature: bundle.signature,
+  };
+}
+
+/**
+ * Sign a canonical content digest with an Ed25519 seed (64 lowercase hex).
+ * Returns the bundle object; serialize with serializeSignatureBundle().
+ */
+function signContentDigest(contentDigest, privateKeySeedHex) {
+  assertContentDigestShape(contentDigest);
+  const privateKey = privateKeyObjectFromSeed(privateKeySeedHex);
+  const publicKeyHex = rawPublicKeyHexFromObject(crypto.createPublicKey(privateKey));
+  const signatureBytes = crypto.sign(null, buildSigningPayload(contentDigest), privateKey);
+  return {
+    algorithm: KDSIG_ALGORITHM,
+    content_digest: contentDigest,
+    profile: KDSIG_PROFILE,
+    profile_version: KDSIG_PROFILE_VERSION,
+    public_key: publicKeyHex,
+    signature: signatureBytes.toString('hex'),
+  };
+}
+
+/**
+ * Verify a parsed bundle against a canonical content digest. Fail-closed:
+ * every mismatch throws with a stable error code. Returns verification
+ * evidence on success.
+ */
+function verifySignatureBundle(bundle, contentDigest, options = {}) {
+  const parsed = parseSignatureBundle(bundle);
+  assertContentDigestShape(contentDigest);
+  if (parsed.content_digest !== contentDigest) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `signature bundle content_digest ${parsed.content_digest} does not match the asset content_digest ${contentDigest}`,
+    );
+  }
+  if (
+    typeof options.expectedPublicKey === 'string'
+    && options.expectedPublicKey.toLowerCase() !== parsed.public_key
+  ) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      'signature bundle public_key does not match the expected pinned key',
+    );
+  }
+  const publicKey = publicKeyObjectFromRaw(parsed.public_key);
+  const signatureBytes = Buffer.from(parsed.signature, 'hex');
+  let valid;
+  try {
+    valid = crypto.verify(null, buildSigningPayload(contentDigest), publicKey, signatureBytes);
+  } catch (e) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      `Ed25519 verification error: ${e.message}`,
+    );
+  }
+  if (valid !== true) {
+    throw signatureError(
+      'KDNA_INTEGRITY_SIGNATURE_FAILED',
+      'Ed25519 signature verification failed: signature does not match the canonical signing payload',
+    );
+  }
+  return {
+    state: 'verified',
+    profile: parsed.profile,
+    profile_version: parsed.profile_version,
+    algorithm: parsed.algorithm,
+    content_digest: parsed.content_digest,
+    public_key: parsed.public_key,
+    key_fingerprint: keyFingerprint(parsed.public_key),
+  };
+}
+
+module.exports = {
+  KDSIG_PROFILE,
+  KDSIG_PROFILE_VERSION,
+  KDSIG_ALGORITHM,
+  SIGNATURE_ENTRY_NAME,
+  buildSigningPayload,
+  generateSigningKeyPair,
+  keyFingerprint,
+  parseSignatureBundle,
+  serializeSignatureBundle,
+  signContentDigest,
+  verifySignatureBundle,
+};

package/src/types.d.ts

@@ -743,6 +743,12 @@ export interface KDNAValidationReport {
   schema_valid: boolean;
   payload_valid: boolean;
   checksums_valid: boolean;
+  signature_valid: boolean;
+  signature_state: 'absent' | 'verified' | 'invalid';
+  signature_evidence: (KDNASignatureEvidenceVerified & {
+    algorithm: 'ed25519';
+    public_key: string;
+  }) | null;
   load_contract_valid: boolean;
   loader_version: string;
   min_loader_version: string | null;
@@ -783,6 +789,22 @@ export interface KDNADigestEvidence {
   runtime_entry_set: KDNADigestValue;
 }
 
+export interface KDNASignatureEvidenceAbsent {
+  state: 'absent';
+}
+
+export interface KDNASignatureEvidenceVerified {
+  state: 'verified';
+  profile: 'kdsig.ed25519';
+  profile_version: '0.1.0';
+  key_fingerprint: string;
+  content_digest: string;
+}
+
+export type KDNASignatureEvidence =
+  | KDNASignatureEvidenceAbsent
+  | KDNASignatureEvidenceVerified;
+
 export interface KDNARuntimeCapsule {
   type: 'kdna.runtime-capsule';
   contract_version: '0.1.0';
@@ -793,7 +815,7 @@ export interface KDNARuntimeCapsule {
     judgment_version: string;
   };
   digests: KDNADigestEvidence;
-  signature: { state: 'absent' };
+  signature: KDNASignatureEvidence;
   access: 'public' | 'licensed' | 'remote';
   profile: 'index' | 'compact' | 'scenario' | 'full';
   context: Record<string, any>;
@@ -804,7 +826,7 @@ export interface KDNARuntimeCapsule {
     input_kind: 'packaged_file' | 'packaged_bytes';
     runtime_eligible: true;
     schema_valid: true;
-    signature_state: 'absent';
+    signature_state: 'absent' | 'verified';
     profile: 'index' | 'compact' | 'scenario' | 'full';
     projection_report?: {
       status: 'complete' | 'partial';
@@ -852,11 +874,72 @@ export function buildRuntimeCapsule(input: {
   projection: Record<string, any>;
   manifest: KDNAManifest;
   digests: KDNADigestEvidence;
-  signature?: { state: 'absent' };
+  signature?: KDNASignatureEvidence;
   inputKind: 'packaged_file' | 'packaged_bytes';
   loadedAt?: string;
   schemaValid?: boolean;
 }): KDNARuntimeCapsule;
+
+export const KDSIG_PROFILE: 'kdsig.ed25519';
+export const KDSIG_PROFILE_VERSION: '0.1.0';
+export const KDSIG_ALGORITHM: 'ed25519';
+export const SIGNATURE_ENTRY_NAME: 'signature.kdsig';
+
+export interface KDNASignatureBundle {
+  algorithm: 'ed25519';
+  content_digest: string;
+  profile: 'kdsig.ed25519';
+  profile_version: '0.1.0';
+  public_key: string;
+  signature: string;
+}
+
+export function buildSigningPayload(contentDigest: string): Uint8Array;
+export function generateSigningKeyPair(): {
+  algorithm: 'ed25519';
+  private_key: string;
+  public_key: string;
+};
+export function keyFingerprint(publicKeyHex: string): string;
+export function parseSignatureBundle(bytes: Uint8Array | string): KDNASignatureBundle;
+export function serializeSignatureBundle(bundle: KDNASignatureBundle): Uint8Array;
+export function signContentDigest(
+  contentDigest: string,
+  privateKeySeedHex: string,
+): KDNASignatureBundle;
+export function verifySignatureBundle(
+  bundle: Uint8Array | string,
+  contentDigest: string,
+  options?: { expectedPublicKey?: string },
+): KDNASignatureEvidenceVerified & { algorithm: 'ed25519'; public_key: string };
+export function signKDNA(
+  input: string | Uint8Array,
+  privateKey: string,
+  options?: { outputPath?: string },
+): Promise<{
+  containerBytes: Uint8Array;
+  bundle: KDNASignatureBundle;
+  bundleBytes: Uint8Array;
+  content_digest: string;
+}>;
+export function signKDNASync(
+  input: string | Uint8Array,
+  privateKey: string,
+  options?: { outputPath?: string },
+): {
+  containerBytes: Uint8Array;
+  bundle: KDNASignatureBundle;
+  bundleBytes: Uint8Array;
+  content_digest: string;
+};
+export function verifyKDNASignature(
+  input: string | Uint8Array,
+  options?: { required?: boolean; expectedPublicKey?: string },
+): Promise<KDNASignatureEvidence>;
+export function verifyKDNASignatureSync(
+  input: string | Uint8Array,
+  options?: { required?: boolean; expectedPublicKey?: string },
+): KDNASignatureEvidence;
 export function loadRuntimeCapsule(
   input: string | Uint8Array,
   options?: {
@@ -1360,6 +1443,11 @@ export interface KDNALayout {
 }
 
 export function readLayout(inputPath: string): KDNALayout;
+export function readLayoutBytes(input: Uint8Array): KDNALayout;
+export function fullEntryBufferMap(layout: KDNALayout): Record<string, Uint8Array>;
+export function contentDigestFromEntryBuffers(
+  buffers: Map<string, Uint8Array> | Record<string, Uint8Array>,
+): string;
 
 export interface KDNAChecksumEntry {
   algorithm: 'sha256';
@@ -1383,7 +1471,7 @@ export function inspect(
   input: string | Uint8Array,
   options?: Record<string, any>,
 ): Record<string, any>;
-export const KDNA_LOADER_VERSION: '0.21.0';
+export const KDNA_LOADER_VERSION: '0.22.0';
 export const STRICT_LOADER_VERSION: RegExp;
 export function parseLoaderVersion(version: unknown): readonly [string, string, string] | null;
 export function compareLoaderVersions(left: string, right: string): -1 | 0 | 1;
@@ -1444,6 +1532,7 @@ export interface KDNALoadPlan {
     source_fingerprint: string;
   } | null;
   checks: Record<string, boolean>;
+  signature_state: 'absent' | 'verified' | 'invalid';
   issues: KDNALoadPlanIssue[];
   source: {
     kind: 'dir' | 'file' | 'memory' | string | null;
@@ -1460,6 +1549,17 @@ export function planLoad(
 ): KDNALoadPlan;
 export function buildChecksums(sourceDir: string): KDNAChecksums;
 export function pack(sourceDir: string, outputPath: string): void;
+export function packEntryMap(map: Record<string, Uint8Array>): Uint8Array;
+export function signContainerBytes(
+  input: Uint8Array,
+  privateKey: string,
+  options?: Record<string, any>,
+): {
+  containerBytes: Uint8Array;
+  bundle: KDNASignatureBundle;
+  bundleBytes: Uint8Array;
+  content_digest: string;
+};
 export function unpack(inputPath: string, outputDir: string): void;
 export function loadAuthorized(
   input: string | Uint8Array,