kit

package.c (70602B)

---

 /* Public signed-package API: the create/verify/unpack/inspect pipelines for
  * portable .tar.gz and native .kpkg packages, composed over the internal
  * dist model (src/dist/). See <kit/package.h> and doc/DISTRIBUTE.md.
  *
  * The pipelines were lifted from the kit pkg tool; the driver keeps only
  * argument parsing, stdout formatting, host-vtable wiring, and trusted-keys
  * path/pin policy. Operational errors emit through ctx->diag (kit_ctx_diagf);
  * arg/CLI errors stay in the driver. */
 
 #include <kit/cas.h>
 #include <kit/package.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "core/diag.h"
 #include "dist/blake2b.h"
 #include "dist/blob.h"
 #include "dist/cas.h"
 #include "dist/deflate.h"
 #include "dist/dist.h"
 #include "dist/kpkg.h"
 #include "dist/lz4.h"
 #include "dist/manifest.h"
 #include "dist/minisig.h"
 #include "dist/release.h"
 #include "dist/tar.h"
 #include "dist/tree.h"
 #include "dist/trust.h"
 
 #define PKG_PATH_BUF 1024u
 #define PKG_META_MANIFEST "kit/package.manifest"
 #define PKG_META_SIG "kit/package.manifest.minisig"
 #define PKG_META_PUB "kit/package.pub"
 #define PKG_DEFAULT_OUTPUT_ID 0u
 #define PKG_MAX_TAR_ENTRIES (DIST_MAX_FILES + DIST_MAX_OUTPUTS + 8u)
 
 _Static_assert(KIT_PKG_KEYID_LEN == DIST_KEYID_LEN, "keyid len");
 _Static_assert(KIT_PKG_PK_LEN == DIST_ED25519_PK_LEN, "pk len");
 _Static_assert(KIT_PKG_SK_LEN == DIST_ED25519_SK_LEN, "sk len");
 _Static_assert(KIT_PKG_NAME_MAX == DIST_NAME_MAX, "name max");
 _Static_assert(KIT_PKG_VERSION_MAX == DIST_VERSION_MAX, "version max");
 _Static_assert(KIT_PKG_TRUSTED_COMMENT_MAX == DIST_TRUSTED_COMMENT_MAX,
                "trusted comment max");
 _Static_assert(KIT_CAS_HASH_LEN == DIST_BLAKE2B_LEN, "hash len");
 _Static_assert((int)KIT_PKG_COMPRESSION_NONE == DIST_KPKG_COMP_NONE,
                "comp none");
 _Static_assert((int)KIT_PKG_COMPRESSION_LZ4_BLOCK_V1 ==
                    DIST_KPKG_COMP_LZ4_BLOCK_V1,
                "comp lz4");
 
 typedef enum PkgNativeShape {
   PKG_NATIVE_FAT,
   PKG_NATIVE_METADATA,
   PKG_NATIVE_THIN
 } PkgNativeShape;
 
 /* kit_pkg_create casts KitPkgShape straight to PkgNativeShape. */
 _Static_assert((int)KIT_PKG_SHAPE_FAT == PKG_NATIVE_FAT, "shape fat");
 _Static_assert((int)KIT_PKG_SHAPE_METADATA == PKG_NATIVE_METADATA,
                "shape metadata");
 _Static_assert((int)KIT_PKG_SHAPE_THIN == PKG_NATIVE_THIN, "shape thin");
 
 typedef struct PkgBlob {
   KitFileData fd;
   int loaded;
   uint8_t id[DIST_BLAKE2B_LEN];
   uint8_t root[DIST_BLAKE2B_LEN];
   uint64_t size;
 } PkgBlob;
 
 typedef struct PkgSource {
   const KitContext* ctx;
   const KitCasHost* host;
   DistTree tree;
   DistTreeEntry entries[DIST_MAX_FILES];
   PkgBlob blobs[DIST_MAX_FILES];
   size_t n_blobs;
   uint8_t tree_id[DIST_BLAKE2B_LEN];
   const uint8_t* tree_bytes;
   size_t tree_size;
   KitWriter* tree_mem;
   KitFileData tree_fd;
   int tree_loaded;
 } PkgSource;
 
 typedef struct PkgVerified {
   DistPackageManifest manifest;
   uint8_t package_id[DIST_BLAKE2B_LEN];
   uint8_t keyid[DIST_KEYID_LEN];
   uint8_t pk[DIST_ED25519_PK_LEN];
   char trusted[DIST_TRUSTED_COMMENT_MAX];
   int tofu_pin;
 } PkgVerified;
 
 typedef struct PkgLoadedTree {
   DistTree tree;
   DistTreeEntry entries[DIST_MAX_FILES];
   uint8_t id[DIST_BLAKE2B_LEN];
   const uint8_t* bytes;
   size_t size;
 } PkgLoadedTree;
 
 /* ---------------------------------------------------------------------- */
 /* shared helpers                                                         */
 /* ---------------------------------------------------------------------- */
 
 static int pkg_write_file(const KitContext* ctx, const char* path,
                           const uint8_t* data, size_t len) {
   KitWriter* w = NULL;
   int rc;
   if (ctx->file_io->open_writer(ctx->file_io->user, path, &w) != KIT_OK) {
     kit_ctx_diagf(ctx, "failed to open output: %s", path);
     return DIST_ERR;
   }
   rc = (len == 0 || kit_writer_write(w, data, len) == KIT_OK) ? DIST_OK
                                                               : DIST_ERR;
   if (kit_writer_status(w) != KIT_OK) rc = DIST_ERR;
   kit_writer_close(w);
   if (rc != DIST_OK) kit_ctx_diagf(ctx, "failed to write: %s", path);
   return rc;
 }
 
 static KitWriter* pkg_mem(const KitContext* ctx) {
   KitWriter* w = NULL;
   if (kit_writer_mem(ctx->heap, &w) != KIT_OK) return NULL;
   return w;
 }
 
 static void pkg_parent_dir(const char* path, char* buf, size_t cap) {
   const char* slash = NULL;
   const char* p;
   size_t n;
   for (p = path; *p; ++p)
     if (*p == '/') slash = p;
   if (!slash) {
     buf[0] = '\0';
     return;
   }
   n = (size_t)(slash - path);
   if (n >= cap) n = cap - 1u;
   memcpy(buf, path, n);
   buf[n] = '\0';
 }
 
 static int pkg_join_path(char* out, size_t cap, const char* dir,
                          const char* rel) {
   size_t dl, rl;
   int slash;
   if (!out || !cap || !dir || !rel) return DIST_ERR;
   dl = strlen(dir);
   rl = strlen(rel);
   slash = dl > 0 && dir[dl - 1u] != '/';
   if (dl + (slash ? 1u : 0u) + rl + 1u > cap) return DIST_ERR;
   memcpy(out, dir, dl);
   if (slash) out[dl++] = '/';
   memcpy(out + dl, rel, rl);
   out[dl + rl] = '\0';
   return DIST_OK;
 }
 
 static int pkg_read_file(const KitContext* ctx, const char* path,
                          KitFileData* out) {
   return ctx->file_io->read_all(ctx->file_io->user, path, out) == KIT_OK
              ? DIST_OK
              : DIST_ERR;
 }
 
 static const DistTarEntry* pkg_find_name(const DistTarEntry* e, size_t n,
                                          const char* name) {
   size_t i;
   for (i = 0; i < n; ++i)
     if (strcmp(e[i].name, name) == 0) return &e[i];
   return NULL;
 }
 
 static uint64_t pkg_align_up(uint64_t v, uint64_t a) {
   return a ? ((v + a - 1u) / a) * a : v;
 }
 
 static int pkg_write_pad(KitWriter* w, uint64_t target) {
   static const uint8_t z[64] = {0};
   while (kit_writer_tell(w) < target) {
     uint64_t left = target - kit_writer_tell(w);
     size_t n = left < sizeof z ? (size_t)left : sizeof z;
     if (kit_writer_write(w, z, n) != KIT_OK) return DIST_ERR;
   }
   return kit_writer_tell(w) == target ? DIST_OK : DIST_ERR;
 }
 
 static void pkg_hash(uint8_t out[DIST_BLAKE2B_LEN], const uint8_t* data,
                      size_t len) {
   dist_blake2b(out, data, len);
 }
 
 static int pkg_parse_id(const char* s, uint8_t out[DIST_BLAKE2B_LEN]) {
   if (!s || strlen(s) != 2u * DIST_BLAKE2B_LEN) return DIST_ERR;
   return dist_hex_decode(out, s, DIST_BLAKE2B_LEN);
 }
 
 static int pkg_cas_rel_path(char* out, size_t cap, const char* kind,
                             const uint8_t id[DIST_BLAKE2B_LEN]) {
   char hex[2 * DIST_BLAKE2B_LEN + 1];
   int n;
   dist_hex_encode(hex, id, DIST_BLAKE2B_LEN);
   n = snprintf(out, cap, "kit/cas/%s/%c%c/%s", kind, hex[0], hex[1], hex);
   return n > 0 && (size_t)n < cap ? DIST_OK : DIST_ERR;
 }
 
 static int pkg_external_id_path(char* out, size_t cap, const char* kind,
                                 const uint8_t id[DIST_BLAKE2B_LEN]) {
   if (strcmp(kind, "tree") == 0) return dist_cas_tree_relpath(out, cap, id);
   if (strcmp(kind, "index") == 0) return dist_cas_index_relpath(out, cap, id);
   if (strcmp(kind, "blob") == 0) return dist_cas_blob_relpath(out, cap, id);
   return DIST_ERR;
 }
 
 static int pkg_external_chunk_path(char* out, size_t cap,
                                    const uint8_t blob[DIST_BLAKE2B_LEN],
                                    uint64_t chunk_index) {
   return dist_cas_chunk_relpath(out, cap, blob, chunk_index);
 }
 
 static int pkg_external_path(char* out, size_t cap, const char* root,
                              const char* rel) {
   /* Reuse the canonical tree-path validator (dist/tree.h): rejects absolute,
    * '.'/'..', backslash, drive-colon, and newline components. */
   if (!dist_tree_path_valid(rel)) return DIST_ERR;
   return pkg_join_path(out, cap, root, rel);
 }
 
 static int pkg_write_external_file(const KitCasHost* host,
                                    const KitContext* ctx, const char* root,
                                    const char* rel, const uint8_t* data,
                                    size_t len) {
   char full[PKG_PATH_BUF], parent[PKG_PATH_BUF];
   if (!root || pkg_external_path(full, sizeof full, root, rel) != DIST_OK)
     return DIST_ERR;
   pkg_parent_dir(full, parent, sizeof parent);
   if (parent[0] && host->mkdir_p(host->user, parent) != 0) return DIST_ERR;
   return pkg_write_file(ctx, full, data, len);
 }
 
 static int pkg_read_external_file(const KitContext* ctx, const char* root,
                                   const char* rel, KitFileData* out) {
   char full[PKG_PATH_BUF];
   if (!root || pkg_external_path(full, sizeof full, root, rel) != DIST_OK)
     return DIST_ERR;
   return pkg_read_file(ctx, full, out);
 }
 
 static int pkg_blob_cmp(const void* ap, const void* bp) {
   const PkgBlob* a = (const PkgBlob*)ap;
   const PkgBlob* b = (const PkgBlob*)bp;
   return memcmp(a->id, b->id, DIST_BLAKE2B_LEN);
 }
 
 /* ---------------------------------------------------------------------- */
 /* source assembly (root walk / cas load)                                 */
 /* ---------------------------------------------------------------------- */
 
 static PkgBlob* pkg_source_find_blob(PkgSource* src,
                                      const uint8_t id[DIST_BLAKE2B_LEN]) {
   size_t i;
   for (i = 0; i < src->n_blobs; ++i)
     if (memcmp(src->blobs[i].id, id, DIST_BLAKE2B_LEN) == 0)
       return &src->blobs[i];
   return NULL;
 }
 
 static void pkg_source_init(PkgSource* src, const KitContext* ctx,
                             const KitCasHost* host) {
   memset(src, 0, sizeof *src);
   src->ctx = ctx;
   src->host = host;
   src->tree.entries = src->entries;
   src->tree.cap_entries = DIST_MAX_FILES;
 }
 
 static void pkg_source_release(PkgSource* src) {
   const KitFileIO* io;
   size_t i;
   if (!src || !src->host) return;
   io = src->host->file_io;
   for (i = 0; i < src->n_blobs; ++i) {
     if (src->blobs[i].loaded && io->release)
       io->release(io->user, &src->blobs[i].fd);
   }
   if (src->tree_loaded && io->release) io->release(io->user, &src->tree_fd);
   if (src->tree_mem) kit_writer_close(src->tree_mem);
   memset(src, 0, sizeof *src);
 }
 
 static int pkg_source_store_blob(PkgSource* src, KitFileData* fd,
                                  const DistBlobInfo* bi, int take_fd) {
   PkgBlob* existing = pkg_source_find_blob(src, bi->id);
   if (existing) {
     if (existing->size != bi->size ||
         memcmp(existing->root, bi->root, DIST_BLAKE2B_LEN) != 0)
       return DIST_ERR;
     return DIST_OK;
   }
   if (src->n_blobs >= DIST_MAX_FILES) return DIST_ERR;
   existing = &src->blobs[src->n_blobs++];
   memset(existing, 0, sizeof *existing);
   memcpy(existing->id, bi->id, DIST_BLAKE2B_LEN);
   memcpy(existing->root, bi->root, DIST_BLAKE2B_LEN);
   existing->size = bi->size;
   if (take_fd) {
     existing->fd = *fd;
     existing->loaded = 1;
     fd->data = NULL;
     fd->size = 0;
     fd->token = NULL;
   }
   return DIST_OK;
 }
 
 static int pkg_source_add_entry(PkgSource* src, const char* tree_path,
                                 uint8_t mode, KitFileData* fd, int take_fd) {
   DistBlobInfo bi;
   DistTreeEntry* e;
   if (src->tree.n_entries >= src->tree.cap_entries) {
     kit_ctx_diagf(src->ctx, "create: too many tree entries");
     return DIST_ERR;
   }
   if (!dist_tree_path_valid(tree_path)) {
     kit_ctx_diagf(src->ctx, "create: unsafe tree path: %s", tree_path);
     return DIST_ERR;
   }
   if (!dist_tree_mode_name(mode)) {
     kit_ctx_diagf(src->ctx, "create: bad tree mode: %s", tree_path);
     return DIST_ERR;
   }
   if (dist_blob_info(&bi, fd->data, fd->size, DIST_BLOB_CHUNK_SIZE_DEFAULT) !=
       DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: failed to hash blob: %s", tree_path);
     return DIST_ERR;
   }
   if (pkg_source_store_blob(src, fd, &bi, take_fd) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: failed to store blob metadata: %s",
                   tree_path);
     return DIST_ERR;
   }
   e = &src->tree.entries[src->tree.n_entries++];
   memset(e, 0, sizeof *e);
   snprintf(e->path, sizeof e->path, "%s", tree_path);
   e->mode = mode;
   e->size = bi.size;
   memcpy(e->blob, bi.id, DIST_BLAKE2B_LEN);
   memcpy(e->root, bi.root, DIST_BLAKE2B_LEN);
   return DIST_OK;
 }
 
 static int pkg_source_walk_file(void* user, const char* source_path,
                                 const char* tree_path, int executable) {
   PkgSource* src = (PkgSource*)user;
   const KitFileIO* io = src->host->file_io;
   KitFileData fd;
   int rc;
   fd.data = NULL;
   fd.size = 0;
   fd.token = NULL;
   if (io->read_all(io->user, source_path, &fd) != KIT_OK) {
     kit_ctx_diagf(src->ctx, "create: cannot read file: %s", source_path);
     return 1;
   }
   rc = pkg_source_add_entry(
       src, tree_path, executable ? DIST_TREE_MODE_EXEC : DIST_TREE_MODE_FILE,
       &fd, 1);
   if (fd.data && io->release) io->release(io->user, &fd);
   return rc == DIST_OK ? 0 : 1;
 }
 
 static int pkg_source_finish_tree(PkgSource* src) {
   char err[128];
   if (dist_tree_sort_validate(&src->tree, err, sizeof err) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: %s", err);
     return DIST_ERR;
   }
   if (kit_writer_mem(src->ctx->heap, &src->tree_mem) != KIT_OK) return DIST_ERR;
   if (dist_tree_emit(&src->tree, src->tree_mem) != DIST_OK ||
       kit_writer_status(src->tree_mem) != KIT_OK) {
     kit_ctx_diagf(src->ctx, "create: failed to emit tree manifest");
     return DIST_ERR;
   }
   src->tree_bytes = kit_writer_mem_bytes(src->tree_mem, &src->tree_size);
   dist_tree_id(src->tree_id, src->tree_bytes, src->tree_size);
   qsort(src->blobs, src->n_blobs, sizeof src->blobs[0], pkg_blob_cmp);
   return DIST_OK;
 }
 
 static int pkg_source_from_root(PkgSource* src, const char* root) {
   if (src->host->walk_regular_files(src->host->user, root, pkg_source_walk_file,
                                     src) != 0) {
     kit_ctx_diagf(src->ctx, "create: failed to walk directory: %s", root);
     return DIST_ERR;
   }
   return pkg_source_finish_tree(src);
 }
 
 static void pkg_cas_init_get(DistCas* cas, const KitCasHost* host,
                              const char* root) {
   memset(cas, 0, sizeof *cas);
   cas->host.file_io = host->file_io;
   cas->host.user = host->user;
   cas->root = root;
 }
 
 static int pkg_source_load_blob_from_cas(PkgSource* src, DistCas* cas,
                                          const DistTreeEntry* e) {
   const KitFileIO* io = src->host->file_io;
   PkgBlob* existing = pkg_source_find_blob(src, e->blob);
   KitFileData fd;
   DistBlobInfo bi;
   if (existing) {
     if (existing->size != e->size ||
         memcmp(existing->root, e->root, DIST_BLAKE2B_LEN) != 0) {
       kit_ctx_diagf(src->ctx, "create: duplicate blob metadata mismatch: %s",
                     e->path);
       return DIST_ERR;
     }
     return DIST_OK;
   }
   fd.data = NULL;
   fd.size = 0;
   fd.token = NULL;
   if (dist_cas_get_blob(cas, e->blob, &fd) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: missing or corrupt blob for: %s", e->path);
     return DIST_ERR;
   }
   if (dist_blob_info(&bi, fd.data, fd.size, DIST_BLOB_CHUNK_SIZE_DEFAULT) !=
           DIST_OK ||
       bi.size != e->size || memcmp(bi.root, e->root, DIST_BLAKE2B_LEN) != 0) {
     if (io->release) io->release(io->user, &fd);
     kit_ctx_diagf(src->ctx, "create: blob root mismatch for: %s", e->path);
     return DIST_ERR;
   }
   if (pkg_source_store_blob(src, &fd, &bi, 1) != DIST_OK) {
     if (fd.data && io->release) io->release(io->user, &fd);
     return DIST_ERR;
   }
   return DIST_OK;
 }
 
 static int pkg_source_from_cas(PkgSource* src, const char* cas_dir,
                                const char* tree_s) {
   DistCas cas;
   char err[128];
   size_t i;
   if (pkg_parse_id(tree_s, src->tree_id) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: bad tree id: %s", tree_s);
     return DIST_ERR;
   }
   pkg_cas_init_get(&cas, src->host, cas_dir);
   src->tree_fd.data = NULL;
   src->tree_fd.size = 0;
   src->tree_fd.token = NULL;
   if (dist_cas_get_tree(&cas, src->tree_id, &src->tree_fd) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: missing or corrupt tree: %s", tree_s);
     return DIST_ERR;
   }
   src->tree_loaded = 1;
   src->tree_bytes = src->tree_fd.data;
   src->tree_size = src->tree_fd.size;
   if (dist_tree_parse(src->tree_bytes, src->tree_size, &src->tree, err,
                       sizeof err) != DIST_OK) {
     kit_ctx_diagf(src->ctx, "create: tree: %s", err);
     return DIST_ERR;
   }
   for (i = 0; i < src->tree.n_entries; ++i) {
     if (pkg_source_load_blob_from_cas(src, &cas, &src->tree.entries[i]) !=
         DIST_OK)
       return DIST_ERR;
   }
   qsort(src->blobs, src->n_blobs, sizeof src->blobs[0], pkg_blob_cmp);
   return DIST_OK;
 }
 
 static int pkg_manifest_from_source(const char* name, const char* version,
                                     const char* desc, const PkgSource* src,
                                     DistPackageManifest* m) {
   size_t i;
   memset(m, 0, sizeof *m);
   snprintf(m->name, sizeof m->name, "%s", name);
   snprintf(m->version, sizeof m->version, "%s", version);
   if (desc) snprintf(m->description, sizeof m->description, "%s", desc);
   m->n_outputs = 1;
   m->outputs[0].id = PKG_DEFAULT_OUTPUT_ID;
   snprintf(m->outputs[0].name, sizeof m->outputs[0].name, "%s", "default");
   memcpy(m->outputs[0].tree, src->tree_id, DIST_BLAKE2B_LEN);
   m->outputs[0].is_default = 1;
   for (i = 0; i < src->tree.n_entries; ++i) {
     DistPackageArtifact* a;
     if (m->n_artifacts >= DIST_MAX_ARTIFACTS) return DIST_ERR;
     a = &m->artifacts[m->n_artifacts++];
     a->output_id = PKG_DEFAULT_OUTPUT_ID;
     snprintf(a->path, sizeof a->path, "%s", src->tree.entries[i].path);
     snprintf(a->kind, sizeof a->kind, "%s", "data");
     a->entry = 1;
   }
   return dist_package_manifest_validate(m, NULL, 0);
 }
 
 static int pkg_sign(KitWriter* out, const KitContext* ctx, const uint8_t* data,
                     size_t len, const DistKeypair* kp,
                     const uint8_t pkgid[DIST_BLAKE2B_LEN], const char* what) {
   char tcomment[DIST_TRUSTED_COMMENT_MAX];
   char pkgid_hex[2 * DIST_BLAKE2B_LEN + 1];
   dist_hex_encode(pkgid_hex, pkgid, DIST_BLAKE2B_LEN);
   snprintf(tcomment, sizeof tcomment, "created=%lld pkgid=%s",
            (long long)(ctx->now > 0 ? ctx->now : 0), pkgid_hex);
   return dist_minisig_sign(out, data, len, kp->sk, kp->keyid, what, tcomment);
 }
 
 /* ---------------------------------------------------------------------- */
 /* create                                                                 */
 /* ---------------------------------------------------------------------- */
 
 static int pkg_create_targz(const KitContext* ctx, const char* out,
                             const PkgSource* src, const uint8_t* man,
                             size_t man_len, const uint8_t* sig, size_t sig_len,
                             const uint8_t* pub, size_t pub_len) {
   KitWriter *tar = NULL, *gz = NULL;
   const uint8_t *tb, *gb;
   size_t tl, gl, i;
   char path[PKG_PATH_BUF];
   int rc = DIST_ERR;
   tar = pkg_mem(ctx);
   gz = pkg_mem(ctx);
   if (!tar || !gz) goto done;
   if (dist_tar_append(tar, PKG_META_MANIFEST, man, man_len) != DIST_OK ||
       dist_tar_append(tar, PKG_META_SIG, sig, sig_len) != DIST_OK ||
       dist_tar_append(tar, PKG_META_PUB, pub, pub_len) != DIST_OK)
     goto done;
   if (pkg_cas_rel_path(path, sizeof path, "tree", src->tree_id) != DIST_OK ||
       dist_tar_append(tar, path, src->tree_bytes, src->tree_size) != DIST_OK)
     goto done;
   for (i = 0; i < src->n_blobs; ++i) {
     if (pkg_cas_rel_path(path, sizeof path, "blob", src->blobs[i].id) !=
             DIST_OK ||
         dist_tar_append(tar, path, src->blobs[i].fd.data,
                         (size_t)src->blobs[i].size) != DIST_OK)
       goto done;
   }
   if (dist_tar_finish(tar) != DIST_OK) goto done;
   tb = kit_writer_mem_bytes(tar, &tl);
   if (dist_gz_compress(gz, tb, tl) != DIST_OK) goto done;
   gb = kit_writer_mem_bytes(gz, &gl);
   rc = pkg_write_file(ctx, out, gb, gl);
 done:
   if (gz) kit_writer_close(gz);
   if (tar) kit_writer_close(tar);
   return rc;
 }
 
 static int pkg_build_native_regions(const KitCasHost* host,
                                     const KitContext* ctx, const PkgSource* src,
                                     uint32_t compression,
                                     const char* external_dir, int embed_content,
                                     KitWriter** index_out,
                                     KitWriter** content_out) {
   KitWriter* index = pkg_mem(ctx);
   KitWriter* content = pkg_mem(ctx);
   size_t bi;
   if (!index || !content) goto fail;
   for (bi = 0; bi < src->n_blobs; ++bi) {
     const PkgBlob* blob = &src->blobs[bi];
     size_t off = 0, ci = 0;
     if (blob->size == 0) continue;
     while (off < blob->size) {
       uint8_t recbuf[DIST_KPKG3_INDEX_RECORD_SIZE];
       DistKpkg3IndexRecord r;
       const uint8_t* raw = blob->fd.data + off;
       size_t raw_len = (size_t)blob->size - off;
       if (raw_len > DIST_KPKG3_CHUNK_SIZE_DEFAULT)
         raw_len = DIST_KPKG3_CHUNK_SIZE_DEFAULT;
       memset(&r, 0, sizeof r);
       memcpy(r.blob_id, blob->id, DIST_BLAKE2B_LEN);
       r.chunk_index = (uint64_t)ci;
       r.content_offset = embed_content ? kit_writer_tell(content) : 0;
       r.raw_size = raw_len;
       r.compression = compression;
       pkg_hash(r.raw_hash, raw, raw_len);
       dist_blob_leaf_hash(r.leaf_hash, r.chunk_index, raw, raw_len);
       if (compression == DIST_KPKG_COMP_NONE) {
         r.stored_size = raw_len;
         pkg_hash(r.stored_hash, raw, raw_len);
         if (embed_content && kit_writer_write(content, raw, raw_len) != KIT_OK)
           goto fail;
         if (!embed_content) {
           char rel[PKG_PATH_BUF];
           if (pkg_external_chunk_path(rel, sizeof rel, blob->id,
                                       r.chunk_index) != DIST_OK ||
               pkg_write_external_file(host, ctx, external_dir, rel, raw,
                                       raw_len) != DIST_OK)
             goto fail;
         }
       } else {
         uint8_t tmp[DIST_KPKG3_CHUNK_SIZE_DEFAULT + 1024u];
         size_t stored_len = 0;
         if (dist_lz4_compress_block(tmp, sizeof tmp, &stored_len, raw,
                                     raw_len) != DIST_OK) {
           kit_ctx_diagf(ctx, "create: lz4-block-v1 compression failed");
           goto fail;
         }
         r.stored_size = stored_len;
         pkg_hash(r.stored_hash, tmp, stored_len);
         if (embed_content &&
             kit_writer_write(content, tmp, stored_len) != KIT_OK)
           goto fail;
         if (!embed_content) {
           char rel[PKG_PATH_BUF];
           if (pkg_external_chunk_path(rel, sizeof rel, blob->id,
                                       r.chunk_index) != DIST_OK ||
               pkg_write_external_file(host, ctx, external_dir, rel, tmp,
                                       stored_len) != DIST_OK)
             goto fail;
         }
       }
       dist_kpkg3_encode_index_record(recbuf, &r);
       if (kit_writer_write(index, recbuf, sizeof recbuf) != KIT_OK) goto fail;
       off += raw_len;
       ++ci;
     }
   }
   *index_out = index;
   *content_out = content;
   return DIST_OK;
 fail:
   if (content) kit_writer_close(content);
   if (index) kit_writer_close(index);
   return DIST_ERR;
 }
 
 static int pkg_create_kpkg(const KitCasHost* host, const KitContext* ctx,
                            const char* out, const DistKeypair* kp,
                            const PkgSource* src, const uint8_t* man,
                            size_t man_len, const uint8_t* sig, size_t sig_len,
                            const uint8_t* pub, size_t pub_len,
                            const uint8_t pkgid[DIST_BLAKE2B_LEN],
                            uint32_t compression, PkgNativeShape shape,
                            const char* external_dir) {
   KitWriter *index = NULL, *content = NULL, *descw = NULL, *descsigw = NULL,
             *pkg = NULL;
   const uint8_t *index_b, *content_b, *desc_b = NULL, *descsig_b = NULL;
   size_t index_l, content_l, desc_l = 0, descsig_l = 0;
   uint8_t tree_root[DIST_BLAKE2B_LEN], index_root[DIST_BLAKE2B_LEN],
       content_root[DIST_BLAKE2B_LEN];
   DistKpkg3Header h;
   uint64_t tree_offset = 0, index_offset = 0, content_offset = 0;
   int embed_tree = shape != PKG_NATIVE_THIN;
   int embed_index = shape != PKG_NATIVE_THIN;
   int embed_content = shape == PKG_NATIVE_FAT;
   int stable = 0, iter, rc = DIST_ERR;
   char tree_url[PKG_PATH_BUF], index_url[PKG_PATH_BUF];
 
   tree_url[0] = '\0';
   index_url[0] = '\0';
   if (shape != PKG_NATIVE_FAT && !external_dir) {
     kit_ctx_diagf(
         ctx, "create: --external DIR is required for non-fat native packages");
     goto done;
   }
   if (pkg_external_id_path(tree_url, sizeof tree_url, "tree", src->tree_id) !=
       DIST_OK)
     goto done;
 
   if (pkg_build_native_regions(host, ctx, src, compression, external_dir,
                                embed_content, &index, &content) != DIST_OK)
     goto done;
   index_b = kit_writer_mem_bytes(index, &index_l);
   content_b = kit_writer_mem_bytes(content, &content_l);
   dist_kpkg3_region_root(tree_root, "tree", embed_tree ? src->tree_bytes : NULL,
                          embed_tree ? src->tree_size : 0);
   dist_kpkg3_region_root(index_root, "index", index_b, index_l);
   dist_kpkg3_region_root(content_root, "content",
                          embed_content ? content_b : NULL,
                          embed_content ? content_l : 0);
   if (!embed_tree &&
       pkg_write_external_file(host, ctx, external_dir, tree_url,
                               src->tree_bytes, src->tree_size) != DIST_OK)
     goto done;
   if (!embed_index) {
     if (pkg_external_id_path(index_url, sizeof index_url, "index",
                              index_root) != DIST_OK ||
         pkg_write_external_file(host, ctx, external_dir, index_url, index_b,
                                 index_l) != DIST_OK)
       goto done;
   }
 
   memset(&h, 0, sizeof h);
   for (iter = 0; iter < 8; ++iter) {
     DistKpkg3Descriptor d;
     uint64_t old_desc_l = desc_l, old_descsig_l = descsig_l;
     if (descw) kit_writer_close(descw);
     if (descsigw) kit_writer_close(descsigw);
     descw = pkg_mem(ctx);
     descsigw = pkg_mem(ctx);
     if (!descw || !descsigw) goto done;
     h.manifest_offset = DIST_KPKG3_HEADER_SIZE;
     h.manifest_size = man_len;
     h.signature_offset = h.manifest_offset + h.manifest_size;
     h.signature_size = sig_len;
     h.descriptor_offset = h.signature_offset + h.signature_size;
     h.descriptor_size = old_desc_l;
     h.descriptor_signature_offset = h.descriptor_offset + h.descriptor_size;
     h.descriptor_signature_size = old_descsig_l;
     h.pubkey_offset =
         h.descriptor_signature_offset + h.descriptor_signature_size;
     h.pubkey_size = pub_len;
     tree_offset = embed_tree ? pkg_align_up(h.pubkey_offset + h.pubkey_size,
                                             DIST_KPKG3_ALIGNMENT)
                              : 0;
     index_offset =
         embed_index
             ? pkg_align_up((embed_tree ? tree_offset + src->tree_size
                                        : h.pubkey_offset + h.pubkey_size),
                            DIST_KPKG3_ALIGNMENT)
             : 0;
     content_offset =
         embed_content
             ? pkg_align_up(
                   (embed_index
                        ? index_offset + index_l
                        : (embed_tree ? tree_offset + src->tree_size
                                      : h.pubkey_offset + h.pubkey_size)),
                   DIST_KPKG3_ALIGNMENT)
             : 0;
 
     memset(&d, 0, sizeof d);
     memcpy(d.package_id, pkgid, DIST_BLAKE2B_LEN);
     d.chunk_size = DIST_KPKG3_CHUNK_SIZE_DEFAULT;
     d.alignment = DIST_KPKG3_ALIGNMENT;
     d.tree_offset = tree_offset;
     d.tree_size = embed_tree ? src->tree_size : 0;
     memcpy(d.tree_root, tree_root, DIST_BLAKE2B_LEN);
     d.index_offset = index_offset;
     d.index_size = embed_index ? index_l : 0;
     d.index_bytes = index_l;
     memcpy(d.index_root, index_root, DIST_BLAKE2B_LEN);
     if (!embed_index)
       snprintf(d.index_url, sizeof d.index_url, "%s", index_url);
     d.content_offset = content_offset;
     d.content_size = embed_content ? content_l : 0;
     memcpy(d.content_root, content_root, DIST_BLAKE2B_LEN);
     d.n_trees = 1;
     memcpy(d.trees[0].tree, src->tree_id, DIST_BLAKE2B_LEN);
     if (embed_tree) {
       d.trees[0].offset = 0;
       d.trees[0].size = src->tree_size;
       d.trees[0].embedded = 1;
     } else {
       snprintf(d.trees[0].url, sizeof d.trees[0].url, "%s", tree_url);
     }
     memcpy(d.trees[0].blake2b, src->tree_id, DIST_BLAKE2B_LEN);
     d.n_chunk_sources = 1;
     if (embed_content) {
       d.chunk_sources[0].kind = DIST_KPKG3_CHUNK_SOURCE_EMBEDDED;
     } else {
       d.chunk_sources[0].kind = DIST_KPKG3_CHUNK_SOURCE_URL_TEMPLATE;
       snprintf(d.chunk_sources[0].tmpl, sizeof d.chunk_sources[0].tmpl, "%s",
                "chunk/{blob-prefix}/{blob}/{chunk}");
     }
     if (dist_kpkg3_descriptor_emit(descw, &d) != DIST_OK) goto done;
     desc_b = kit_writer_mem_bytes(descw, &desc_l);
     if (pkg_sign(descsigw, ctx, desc_b, desc_l, kp, pkgid,
                  "kit kpkg encoding descriptor") != DIST_OK)
       goto done;
     descsig_b = kit_writer_mem_bytes(descsigw, &descsig_l);
     if (desc_l == old_desc_l && descsig_l == old_descsig_l) {
       stable = 1;
       break;
     }
   }
   if (!stable) goto done;
 
   pkg = pkg_mem(ctx);
   if (!pkg) goto done;
   if (dist_kpkg3_write_header(pkg, &h) != DIST_OK ||
       kit_writer_write(pkg, man, man_len) != KIT_OK ||
       kit_writer_write(pkg, sig, sig_len) != KIT_OK ||
       kit_writer_write(pkg, desc_b, desc_l) != KIT_OK ||
       kit_writer_write(pkg, descsig_b, descsig_l) != KIT_OK ||
       kit_writer_write(pkg, pub, pub_len) != KIT_OK ||
       (embed_tree &&
        (pkg_write_pad(pkg, tree_offset) != DIST_OK ||
         kit_writer_write(pkg, src->tree_bytes, src->tree_size) != KIT_OK)) ||
       (embed_index && (pkg_write_pad(pkg, index_offset) != DIST_OK ||
                        kit_writer_write(pkg, index_b, index_l) != KIT_OK)) ||
       (embed_content &&
        (pkg_write_pad(pkg, content_offset) != DIST_OK ||
         kit_writer_write(pkg, content_b, content_l) != KIT_OK)))
     goto done;
   {
     const uint8_t* bytes;
     size_t len;
     bytes = kit_writer_mem_bytes(pkg, &len);
     rc = pkg_write_file(ctx, out, bytes, len);
   }
 
 done:
   if (pkg) kit_writer_close(pkg);
   if (descsigw) kit_writer_close(descsigw);
   if (descw) kit_writer_close(descw);
   if (content) kit_writer_close(content);
   if (index) kit_writer_close(index);
   return rc;
 }
 
 KitStatus kit_pkg_create(const KitContext* ctx, const KitCasHost* host,
                          const KitPkgCreateOptions* opts,
                          KitPkgCreateResult* result) {
   DistKeypair kp;
   DistPackageManifest m;
   PkgSource src;
   KitWriter *manw = NULL, *sigw = NULL, *pubw = NULL;
   const uint8_t *man_b, *sig_b, *pub_b;
   size_t man_l, sig_l, pub_l;
   uint8_t pkgid[DIST_BLAKE2B_LEN];
   int rc = DIST_ERR;
   if (!ctx || !host || !opts || !result || !opts->sk || !opts->keyid ||
       !opts->out_path)
     return KIT_INVALID;
 
   memset(&kp, 0, sizeof kp);
   memcpy(kp.sk, opts->sk, DIST_ED25519_SK_LEN);
   memcpy(kp.keyid, opts->keyid, DIST_KEYID_LEN);
   memcpy(kp.pk, kp.sk + DIST_ED25519_SEED_LEN, DIST_ED25519_PK_LEN);
 
   pkg_source_init(&src, ctx, host);
   if (opts->root_dir) {
     if (pkg_source_from_root(&src, opts->root_dir) != DIST_OK) goto done;
   } else {
     if (pkg_source_from_cas(&src, opts->cas_dir, opts->tree_id) != DIST_OK)
       goto done;
   }
   if (pkg_manifest_from_source(opts->name, opts->version, opts->description,
                                &src, &m) != DIST_OK) {
     kit_ctx_diagf(ctx, "create: failed to build package manifest");
     goto done;
   }
 
   manw = pkg_mem(ctx);
   sigw = pkg_mem(ctx);
   pubw = pkg_mem(ctx);
   if (!manw || !sigw || !pubw) goto done;
   if (dist_package_manifest_emit(&m, manw) != DIST_OK) goto done;
   man_b = kit_writer_mem_bytes(manw, &man_l);
   pkg_hash(pkgid, man_b, man_l);
   if (pkg_sign(sigw, ctx, man_b, man_l, &kp, pkgid, "signature from kit pkg") !=
       DIST_OK)
     goto done;
   sig_b = kit_writer_mem_bytes(sigw, &sig_l);
   if (dist_minisig_emit_pubkey(pubw, &kp) != DIST_OK) goto done;
   pub_b = kit_writer_mem_bytes(pubw, &pub_l);
 
   if (opts->format == KIT_PKG_FORMAT_TARGZ)
     rc = pkg_create_targz(ctx, opts->out_path, &src, man_b, man_l, sig_b, sig_l,
                           pub_b, pub_l);
   else
     rc = pkg_create_kpkg(
         host, ctx, opts->out_path, &kp, &src, man_b, man_l, sig_b, sig_l, pub_b,
         pub_l, pkgid, (uint32_t)opts->compression,
         (PkgNativeShape)opts->native_shape, opts->external_dir);
   if (rc == DIST_OK) {
     result->n_files = src.tree.n_entries;
     memcpy(result->package_id, pkgid, DIST_BLAKE2B_LEN);
   }
 
 done:
   if (pubw) kit_writer_close(pubw);
   if (sigw) kit_writer_close(sigw);
   if (manw) kit_writer_close(manw);
   pkg_source_release(&src);
   return rc == DIST_OK ? KIT_OK : KIT_ERR;
 }
 
 /* ---------------------------------------------------------------------- */
 /* key resolution + manifest verification                                 */
 /* ---------------------------------------------------------------------- */
 
 static int pkg_resolve_key(const KitContext* ctx,
                            const uint8_t keyid[DIST_KEYID_LEN],
                            const uint8_t* bundled_pub, size_t bundled_pub_size,
                            const KitPkgVerifyOptions* opts,
                            uint8_t pk[DIST_ED25519_PK_LEN], int* tofu_pin) {
   uint8_t kid_chk[DIST_KEYID_LEN];
   *tofu_pin = 0;
   if (opts->pubkey_bytes) {
     if (dist_minisig_parse_pubkey(opts->pubkey_bytes, opts->pubkey_len, pk,
                                   kid_chk) != DIST_OK ||
         memcmp(kid_chk, keyid, DIST_KEYID_LEN) != 0) {
       kit_ctx_diagf(ctx, "public key id does not match signature");
       return DIST_ERR;
     }
     return DIST_OK;
   }
   if (opts->trusted_keys &&
       dist_trust_lookup(opts->trusted_keys, opts->trusted_keys_len, keyid,
                         pk) == DIST_OK)
     return DIST_OK;
   if (!opts->tofu) {
     char hex[2 * DIST_KEYID_LEN + 1];
     dist_hex_encode(hex, keyid, DIST_KEYID_LEN);
     kit_ctx_diagf(ctx, "untrusted signer (key id %s)", hex);
     return DIST_ERR;
   }
   if (!bundled_pub || bundled_pub_size == 0 ||
       dist_minisig_parse_pubkey(bundled_pub, bundled_pub_size, pk, kid_chk) !=
           DIST_OK ||
       memcmp(kid_chk, keyid, DIST_KEYID_LEN) != 0) {
     kit_ctx_diagf(ctx, "--tofu: bundled public key is missing or mismatched");
     return DIST_ERR;
   }
   *tofu_pin = 1;
   return DIST_OK;
 }
 
 static int pkg_verify_manifest(const KitContext* ctx, const uint8_t* man,
                                size_t man_len, const uint8_t* sig,
                                size_t sig_len, const uint8_t* pub,
                                size_t pub_len, const KitPkgVerifyOptions* opts,
                                PkgVerified* out) {
   char err[128], pkgid_hex[2 * DIST_BLAKE2B_LEN + 1];
   const char* pidp;
   memset(out, 0, sizeof *out);
   if (dist_minisig_sig_keyid(sig, sig_len, out->keyid) != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed signature");
     return DIST_ERR;
   }
   if (pkg_resolve_key(ctx, out->keyid, pub, pub_len, opts, out->pk,
                       &out->tofu_pin) != DIST_OK)
     return DIST_ERR;
   if (dist_minisig_verify(sig, sig_len, man, man_len, out->pk, out->trusted,
                           sizeof out->trusted) != DIST_OK) {
     kit_ctx_diagf(ctx, "signature verification FAILED");
     return DIST_ERR;
   }
   pkg_hash(out->package_id, man, man_len);
   dist_hex_encode(pkgid_hex, out->package_id, DIST_BLAKE2B_LEN);
   pidp = strstr(out->trusted, "pkgid=");
   if (!pidp || strncmp(pidp + 6, pkgid_hex, 2 * DIST_BLAKE2B_LEN) != 0) {
     kit_ctx_diagf(ctx, "trusted comment does not match package id");
     return DIST_ERR;
   }
   if (dist_package_manifest_parse(man, man_len, &out->manifest, err,
                                   sizeof err) != DIST_OK) {
     kit_ctx_diagf(ctx, "manifest: %s", err);
     return DIST_ERR;
   }
   return DIST_OK;
 }
 
 static const DistPackageOutput* pkg_default_output(
     const DistPackageManifest* m) {
   size_t i;
   for (i = 0; i < m->n_outputs; ++i)
     if (m->outputs[i].is_default) return &m->outputs[i];
   return m->n_outputs ? &m->outputs[0] : NULL;
 }
 
 static int pkg_parse_tree_object(const KitContext* ctx, PkgLoadedTree* out,
                                  const uint8_t id[DIST_BLAKE2B_LEN],
                                  const uint8_t* data, size_t len,
                                  const char* label) {
   uint8_t got[DIST_BLAKE2B_LEN];
   char err[128];
   memset(out, 0, sizeof *out);
   dist_tree_id(got, data, len);
   if (memcmp(got, id, DIST_BLAKE2B_LEN) != 0) {
     kit_ctx_diagf(ctx, "tree id mismatch: %s", label);
     return DIST_ERR;
   }
   out->tree.entries = out->entries;
   out->tree.cap_entries = DIST_MAX_FILES;
   if (dist_tree_parse(data, len, &out->tree, err, sizeof err) != DIST_OK) {
     kit_ctx_diagf(ctx, "tree: %s", err);
     return DIST_ERR;
   }
   memcpy(out->id, id, DIST_BLAKE2B_LEN);
   out->bytes = data;
   out->size = len;
   return DIST_OK;
 }
 
 static int pkg_verify_artifact_overlays(const KitContext* ctx,
                                         const DistPackageManifest* m,
                                         const DistPackageOutput* out,
                                         const DistTree* tree) {
   size_t i;
   for (i = 0; i < m->n_artifacts; ++i) {
     const DistPackageArtifact* a = &m->artifacts[i];
     if (a->output_id != out->id) continue;
     if (!dist_tree_find(tree, a->path)) {
       kit_ctx_diagf(ctx, "artifact path not in output tree: %s", a->path);
       return DIST_ERR;
     }
   }
   return DIST_OK;
 }
 
 static int pkg_write_output_file(const KitCasHost* host, const KitContext* ctx,
                                  const char* out_dir, const DistTreeEntry* e,
                                  const uint8_t* data, size_t len) {
   char full[PKG_PATH_BUF], parent[PKG_PATH_BUF];
   if (pkg_join_path(full, sizeof full, out_dir, e->path) != DIST_OK) {
     kit_ctx_diagf(ctx, "output path too long: %s", e->path);
     return DIST_ERR;
   }
   pkg_parent_dir(full, parent, sizeof parent);
   if (parent[0] && host->mkdir_p(host->user, parent) != 0) return DIST_ERR;
   if (pkg_write_file(ctx, full, data, len) != DIST_OK) return DIST_ERR;
   if (e->mode == DIST_TREE_MODE_EXEC &&
       host->mark_executable(host->user, full) != 0)
     return DIST_ERR;
   return DIST_OK;
 }
 
 /* ---------------------------------------------------------------------- */
 /* portable (.tar.gz) verify / unpack                                     */
 /* ---------------------------------------------------------------------- */
 
 static const DistTarEntry* pkg_portable_find_cas(
     const DistTarEntry* entries, size_t ne, const char* kind,
     const uint8_t id[DIST_BLAKE2B_LEN]) {
   char path[PKG_PATH_BUF];
   if (pkg_cas_rel_path(path, sizeof path, kind, id) != DIST_OK) return NULL;
   return pkg_find_name(entries, ne, path);
 }
 
 static int pkg_verify_blob_bytes(const DistTreeEntry* e, const uint8_t* data,
                                  size_t len) {
   DistBlobInfo bi;
   if (dist_blob_info(&bi, data, len, DIST_BLOB_CHUNK_SIZE_DEFAULT) != DIST_OK)
     return DIST_ERR;
   return bi.size == e->size && memcmp(bi.id, e->blob, DIST_BLAKE2B_LEN) == 0 &&
                  memcmp(bi.root, e->root, DIST_BLAKE2B_LEN) == 0
              ? DIST_OK
              : DIST_ERR;
 }
 
 static int pkg_verify_portable_tree(const KitCasHost* host,
                                     const KitContext* ctx, const PkgVerified* v,
                                     const DistPackageOutput* out,
                                     const DistTarEntry* entries, size_t ne,
                                     const char* out_dir) {
   const DistTarEntry* te =
       pkg_portable_find_cas(entries, ne, "tree", out->tree);
   PkgLoadedTree tree;
   size_t i;
   if (!te) {
     kit_ctx_diagf(ctx, "portable package missing tree object");
     return DIST_ERR;
   }
   if (pkg_parse_tree_object(ctx, &tree, out->tree, te->data, te->size,
                             out->name) != DIST_OK)
     return DIST_ERR;
   if (pkg_verify_artifact_overlays(ctx, &v->manifest, out, &tree.tree) !=
       DIST_OK)
     return DIST_ERR;
   for (i = 0; i < tree.tree.n_entries; ++i) {
     const DistTreeEntry* e = &tree.tree.entries[i];
     const DistTarEntry* be =
         pkg_portable_find_cas(entries, ne, "blob", e->blob);
     if (!be) {
       kit_ctx_diagf(ctx, "portable package missing blob: %s", e->path);
       return DIST_ERR;
     }
     if (pkg_verify_blob_bytes(e, be->data, be->size) != DIST_OK) {
       kit_ctx_diagf(ctx, "blob hash mismatch: %s", e->path);
       return DIST_ERR;
     }
     if (out_dir && pkg_write_output_file(host, ctx, out_dir, e, be->data,
                                          be->size) != DIST_OK)
       return DIST_ERR;
   }
   return DIST_OK;
 }
 
 static int pkg_load_portable(const KitContext* ctx, const uint8_t* data,
                              size_t len, KitWriter** inflated_out,
                              DistTarEntry* entries, size_t* ne) {
   KitWriter* inflated = NULL;
   const uint8_t* bytes;
   size_t ilen;
   inflated = pkg_mem(ctx);
   if (!inflated || dist_gz_decompress(inflated, data, len) != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed portable package");
     if (inflated) kit_writer_close(inflated);
     return DIST_ERR;
   }
   bytes = kit_writer_mem_bytes(inflated, &ilen);
   if (dist_tar_iter(bytes, ilen, entries, PKG_MAX_TAR_ENTRIES, ne) != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed portable tar");
     kit_writer_close(inflated);
     return DIST_ERR;
   }
   *inflated_out = inflated;
   return DIST_OK;
 }
 
 static int pkg_verify_portable(const KitContext* ctx, const KitCasHost* host,
                                const KitPkgVerifyOptions* opts,
                                PkgVerified* v) {
   KitWriter* inflated = NULL;
   DistTarEntry entries[PKG_MAX_TAR_ENTRIES];
   size_t ne = 0, oi;
   const DistTarEntry *man, *sig, *pub;
   const DistPackageOutput* def;
   int rc = DIST_ERR;
   if (pkg_load_portable(ctx, opts->pkg_data, opts->pkg_len, &inflated, entries,
                         &ne) != DIST_OK)
     return DIST_ERR;
   man = pkg_find_name(entries, ne, PKG_META_MANIFEST);
   sig = pkg_find_name(entries, ne, PKG_META_SIG);
   pub = pkg_find_name(entries, ne, PKG_META_PUB);
   if (!man || !sig) {
     kit_ctx_diagf(ctx, "package missing manifest or signature");
     goto done;
   }
   if (pkg_verify_manifest(ctx, man->data, man->size, sig->data, sig->size,
                           pub ? pub->data : NULL, pub ? pub->size : 0, opts,
                           v) != DIST_OK)
     goto done;
   def = pkg_default_output(&v->manifest);
   if (!def) goto done;
   for (oi = 0; oi < v->manifest.n_outputs; ++oi) {
     const DistPackageOutput* out = &v->manifest.outputs[oi];
     if (pkg_verify_portable_tree(host, ctx, v, out, entries, ne,
                                  out == def ? opts->unpack_dir : NULL) !=
         DIST_OK)
       goto done;
   }
   rc = DIST_OK;
 done:
   if (inflated) kit_writer_close(inflated);
   return rc;
 }
 
 /* ---------------------------------------------------------------------- */
 /* native (.kpkg) verify / unpack                                        */
 /* ---------------------------------------------------------------------- */
 
 static int pkg_bounds3(const DistKpkg3Header* h, size_t len) {
   uint64_t ranges[][2] = {
       {h->manifest_offset, h->manifest_size},
       {h->signature_offset, h->signature_size},
       {h->descriptor_offset, h->descriptor_size},
       {h->descriptor_signature_offset, h->descriptor_signature_size},
       {h->pubkey_offset, h->pubkey_size}};
   size_t i;
   for (i = 0; i < sizeof ranges / sizeof ranges[0]; ++i)
     if (ranges[i][0] > len || ranges[i][1] > len - ranges[i][0])
       return DIST_ERR;
   return DIST_OK;
 }
 
 static int pkg_range_ok(uint64_t off, uint64_t size, size_t len) {
   return off <= len && size <= len - off;
 }
 
 static const DistKpkg3TreeObject* pkg_descriptor_find_tree(
     const DistKpkg3Descriptor* d, const uint8_t id[DIST_BLAKE2B_LEN]) {
   size_t i;
   for (i = 0; i < d->n_trees; ++i)
     if (memcmp(d->trees[i].tree, id, DIST_BLAKE2B_LEN) == 0)
       return &d->trees[i];
   return NULL;
 }
 
 static int pkg_descriptor_has_embedded_chunks(const DistKpkg3Descriptor* d) {
   size_t i;
   for (i = 0; i < d->n_chunk_sources; ++i)
     if (d->chunk_sources[i].kind == DIST_KPKG3_CHUNK_SOURCE_EMBEDDED) return 1;
   return 0;
 }
 
 static const char* pkg_descriptor_chunk_template(const DistKpkg3Descriptor* d) {
   size_t i;
   for (i = 0; i < d->n_chunk_sources; ++i)
     if (d->chunk_sources[i].kind == DIST_KPKG3_CHUNK_SOURCE_URL_TEMPLATE)
       return d->chunk_sources[i].tmpl;
   return NULL;
 }
 
 static int pkg_render_chunk_template(char* out, size_t cap, const char* tmpl,
                                      const uint8_t blob[DIST_BLAKE2B_LEN],
                                      uint64_t chunk_index) {
   char blob_hex[2 * DIST_BLAKE2B_LEN + 1];
   char blob_prefix[3];
   char chunk_dec[24];
   size_t oi = 0, i;
   dist_hex_encode(blob_hex, blob, DIST_BLAKE2B_LEN);
   blob_prefix[0] = blob_hex[0];
   blob_prefix[1] = blob_hex[1];
   blob_prefix[2] = '\0';
   snprintf(chunk_dec, sizeof chunk_dec, "%llu",
            (unsigned long long)chunk_index);
   for (i = 0; tmpl[i];) {
     const char* repl = NULL;
     size_t repl_len = 0;
     if (strncmp(tmpl + i, "{blob}", 6) == 0) {
       repl = blob_hex;
       repl_len = strlen(blob_hex);
       i += 6;
     } else if (strncmp(tmpl + i, "{blob-prefix}", 13) == 0) {
       repl = blob_prefix;
       repl_len = strlen(blob_prefix);
       i += 13;
     } else if (strncmp(tmpl + i, "{chunk}", 7) == 0) {
       repl = chunk_dec;
       repl_len = strlen(chunk_dec);
       i += 7;
     } else {
       if (oi + 1u >= cap) return DIST_ERR;
       out[oi++] = tmpl[i++];
       continue;
     }
     if (oi + repl_len >= cap) return DIST_ERR;
     memcpy(out + oi, repl, repl_len);
     oi += repl_len;
   }
   if (oi >= cap) return DIST_ERR;
   out[oi] = '\0';
   return dist_tree_path_valid(out) ? DIST_OK : DIST_ERR;
 }
 
 static int pkg_verify_native_index_sorted(const uint8_t* index_b,
                                           size_t index_l,
                                           const DistKpkg3Descriptor* d) {
   DistKpkg3IndexRecord prev;
   size_t off;
   int have_prev = 0;
   int embedded_chunks = pkg_descriptor_has_embedded_chunks(d);
   if (index_l != d->index_bytes || index_l % DIST_KPKG3_INDEX_RECORD_SIZE != 0)
     return DIST_ERR;
   memset(&prev, 0, sizeof prev);
   for (off = 0; off < index_l; off += DIST_KPKG3_INDEX_RECORD_SIZE) {
     DistKpkg3IndexRecord r;
     int cmp;
     if (dist_kpkg3_decode_index_record(
             index_b + off, DIST_KPKG3_INDEX_RECORD_SIZE, &r) != DIST_OK)
       return DIST_ERR;
     if (r.raw_size == 0 || r.raw_size > d->chunk_size ||
         !dist_kpkg_compression_name(r.compression))
       return DIST_ERR;
     if (embedded_chunks) {
       if (r.content_offset > d->content_size ||
           r.stored_size > d->content_size - r.content_offset)
         return DIST_ERR;
     } else if (r.content_offset != 0) {
       return DIST_ERR;
     }
     if (!have_prev) {
       if (r.chunk_index != 0) return DIST_ERR;
     } else {
       cmp = memcmp(prev.blob_id, r.blob_id, DIST_BLAKE2B_LEN);
       if (cmp > 0) return DIST_ERR;
       if (cmp == 0) {
         if (r.chunk_index <= prev.chunk_index) return DIST_ERR;
       } else if (r.chunk_index != 0) {
         return DIST_ERR;
       }
     }
     prev = r;
     have_prev = 1;
   }
   return DIST_OK;
 }
 
 static int pkg_native_load_tree(const KitContext* ctx, const uint8_t* data,
                                 size_t len, const DistKpkg3Descriptor* d,
                                 const DistPackageOutput* out,
                                 const char* external_dir, PkgLoadedTree* tree) {
   const DistKpkg3TreeObject* obj = pkg_descriptor_find_tree(d, out->tree);
   const uint8_t* bytes;
   uint8_t h[DIST_BLAKE2B_LEN];
   (void)len;
   if (!obj || !obj->embedded) {
     KitFileData fd;
     char rel[PKG_PATH_BUF];
     int rc;
     if (!obj || !external_dir) {
       kit_ctx_diagf(ctx, "external tree object is missing");
       return DIST_ERR;
     }
     if (obj->url[0])
       snprintf(rel, sizeof rel, "%s", obj->url);
     else if (pkg_external_id_path(rel, sizeof rel, "tree", out->tree) !=
              DIST_OK)
       return DIST_ERR;
     fd.data = NULL;
     fd.size = 0;
     fd.token = NULL;
     if (pkg_read_external_file(ctx, external_dir, rel, &fd) != DIST_OK) {
       kit_ctx_diagf(ctx, "missing external tree object: %s", rel);
       return DIST_ERR;
     }
     pkg_hash(h, fd.data, fd.size);
     if (memcmp(h, obj->blake2b, DIST_BLAKE2B_LEN) != 0 ||
         memcmp(h, out->tree, DIST_BLAKE2B_LEN) != 0) {
       ctx->file_io->release(ctx->file_io->user, &fd);
       kit_ctx_diagf(ctx, "tree object hash mismatch");
       return DIST_ERR;
     }
     rc = pkg_parse_tree_object(ctx, tree, out->tree, fd.data, fd.size,
                                out->name);
     ctx->file_io->release(ctx->file_io->user, &fd);
     tree->bytes = NULL;
     tree->size = 0;
     return rc;
   }
   if (obj->offset > d->tree_size || obj->size > d->tree_size - obj->offset)
     return DIST_ERR;
   bytes = data + d->tree_offset + obj->offset;
   pkg_hash(h, bytes, (size_t)obj->size);
   if (memcmp(h, obj->blake2b, DIST_BLAKE2B_LEN) != 0 ||
       memcmp(h, out->tree, DIST_BLAKE2B_LEN) != 0) {
     kit_ctx_diagf(ctx, "tree object hash mismatch");
     return DIST_ERR;
   }
   return pkg_parse_tree_object(ctx, tree, out->tree, bytes, (size_t)obj->size,
                                out->name);
 }
 
 static int pkg_native_load_index(const KitContext* ctx, const uint8_t* data,
                                  const DistKpkg3Descriptor* d,
                                  const char* external_dir, KitFileData* fd,
                                  const uint8_t** index_b, size_t* index_l) {
   uint8_t root[DIST_BLAKE2B_LEN];
   fd->data = NULL;
   fd->size = 0;
   fd->token = NULL;
   if (d->index_size != 0) {
     if (d->index_size != d->index_bytes) return DIST_ERR;
     *index_b = data + d->index_offset;
     *index_l = (size_t)d->index_size;
   } else {
     char rel[PKG_PATH_BUF];
     if (!external_dir) {
       kit_ctx_diagf(ctx, "external index is missing");
       return DIST_ERR;
     }
     if (d->index_url[0])
       snprintf(rel, sizeof rel, "%s", d->index_url);
     else if (pkg_external_id_path(rel, sizeof rel, "index", d->index_root) !=
              DIST_OK)
       return DIST_ERR;
     if (pkg_read_external_file(ctx, external_dir, rel, fd) != DIST_OK) {
       kit_ctx_diagf(ctx, "missing external index: %s", rel);
       return DIST_ERR;
     }
     *index_b = fd->data;
     *index_l = fd->size;
   }
   if (*index_l != d->index_bytes) return DIST_ERR;
   dist_kpkg3_region_root(root, "index", *index_b, *index_l);
   return memcmp(root, d->index_root, DIST_BLAKE2B_LEN) == 0 ? DIST_OK
                                                             : DIST_ERR;
 }
 
 static int pkg_decode_native_chunk(KitWriter* raww, const uint8_t* stored,
                                    size_t stored_len,
                                    const DistKpkg3Descriptor* d,
                                    const DistKpkg3IndexRecord* r) {
   uint8_t sh[DIST_BLAKE2B_LEN], rh[DIST_BLAKE2B_LEN], leaf[DIST_BLAKE2B_LEN];
   if (r->raw_size == 0 || r->raw_size > d->chunk_size ||
       r->stored_size != stored_len)
     return DIST_ERR;
   pkg_hash(sh, stored, (size_t)r->stored_size);
   if (memcmp(sh, r->stored_hash, DIST_BLAKE2B_LEN) != 0) return DIST_ERR;
   if (r->compression == DIST_KPKG_COMP_NONE) {
     if (r->raw_size != r->stored_size) return DIST_ERR;
     pkg_hash(rh, stored, (size_t)r->stored_size);
     dist_blob_leaf_hash(leaf, r->chunk_index, stored, (size_t)r->stored_size);
     if (memcmp(rh, r->raw_hash, DIST_BLAKE2B_LEN) != 0 ||
         memcmp(leaf, r->leaf_hash, DIST_BLAKE2B_LEN) != 0 ||
         kit_writer_write(raww, stored, (size_t)r->stored_size) != KIT_OK)
       return DIST_ERR;
   } else if (r->compression == DIST_KPKG_COMP_LZ4_BLOCK_V1) {
     uint8_t tmp[DIST_KPKG3_CHUNK_SIZE_DEFAULT];
     if (r->raw_size > sizeof tmp ||
         dist_lz4_decompress_block(tmp, (size_t)r->raw_size, stored,
                                   (size_t)r->stored_size) != DIST_OK)
       return DIST_ERR;
     pkg_hash(rh, tmp, (size_t)r->raw_size);
     dist_blob_leaf_hash(leaf, r->chunk_index, tmp, (size_t)r->raw_size);
     if (memcmp(rh, r->raw_hash, DIST_BLAKE2B_LEN) != 0 ||
         memcmp(leaf, r->leaf_hash, DIST_BLAKE2B_LEN) != 0 ||
         kit_writer_write(raww, tmp, (size_t)r->raw_size) != KIT_OK)
       return DIST_ERR;
   } else {
     return DIST_ERR;
   }
   return DIST_OK;
 }
 
 static int pkg_native_load_stored_chunk(
     const KitContext* ctx, const uint8_t* data, const DistKpkg3Descriptor* d,
     const DistKpkg3IndexRecord* r, const char* external_dir,
     const char* chunk_template, KitFileData* fd, const uint8_t** stored,
     size_t* stored_len) {
   fd->data = NULL;
   fd->size = 0;
   fd->token = NULL;
   if (pkg_descriptor_has_embedded_chunks(d)) {
     if (r->content_offset > d->content_size ||
         r->stored_size > d->content_size - r->content_offset)
       return DIST_ERR;
     *stored = data + d->content_offset + r->content_offset;
     *stored_len = (size_t)r->stored_size;
     return DIST_OK;
   }
   {
     char rel[PKG_PATH_BUF];
     if (!external_dir) return DIST_ERR;
     if (chunk_template) {
       if (pkg_render_chunk_template(rel, sizeof rel, chunk_template, r->blob_id,
                                     r->chunk_index) != DIST_OK)
         return DIST_ERR;
     } else if (dist_cas_chunk_relpath(rel, sizeof rel, r->blob_id,
                                       r->chunk_index) != DIST_OK) {
       return DIST_ERR;
     }
     if (pkg_read_external_file(ctx, external_dir, rel, fd) != DIST_OK) {
       kit_ctx_diagf(ctx, "missing external chunk: %s", rel);
       return DIST_ERR;
     }
     *stored = fd->data;
     *stored_len = fd->size;
     return DIST_OK;
   }
 }
 
 static int pkg_native_reconstruct_blob(
     const KitContext* ctx, const uint8_t* data, const uint8_t* index_b,
     size_t index_l, const DistKpkg3Descriptor* d, const DistTreeEntry* e,
     const char* external_dir, const char* chunk_template,
     KitWriter** raww_out) {
   KitWriter* raww = pkg_mem(ctx);
   uint64_t want_chunk = 0;
   size_t off;
   int saw = 0;
   if (!raww) return DIST_ERR;
   if (index_l % DIST_KPKG3_INDEX_RECORD_SIZE != 0) goto fail;
   for (off = 0; off < index_l; off += DIST_KPKG3_INDEX_RECORD_SIZE) {
     DistKpkg3IndexRecord r;
     KitFileData chunk_fd;
     const uint8_t* stored;
     size_t stored_len;
     int cmp;
     if (dist_kpkg3_decode_index_record(
             index_b + off, DIST_KPKG3_INDEX_RECORD_SIZE, &r) != DIST_OK)
       goto fail;
     cmp = memcmp(r.blob_id, e->blob, DIST_BLAKE2B_LEN);
     if (cmp < 0) continue;
     if (cmp > 0 && saw) break;
     if (cmp > 0) continue;
     saw = 1;
     if (r.chunk_index != want_chunk++) goto fail;
     if (pkg_native_load_stored_chunk(ctx, data, d, &r, external_dir,
                                      chunk_template, &chunk_fd, &stored,
                                      &stored_len) != DIST_OK)
       goto fail;
     if (pkg_decode_native_chunk(raww, stored, stored_len, d, &r) != DIST_OK) {
       if (chunk_fd.data && ctx->file_io->release)
         ctx->file_io->release(ctx->file_io->user, &chunk_fd);
       goto fail;
     }
     if (chunk_fd.data && ctx->file_io->release)
       ctx->file_io->release(ctx->file_io->user, &chunk_fd);
   }
   *raww_out = raww;
   return DIST_OK;
 fail:
   kit_writer_close(raww);
   return DIST_ERR;
 }
 
 static int pkg_verify_native_tree(
     const KitCasHost* host, const KitContext* ctx, const uint8_t* data,
     size_t len, const uint8_t* index_b, size_t index_l,
     const DistKpkg3Descriptor* d, const PkgVerified* v,
     const DistPackageOutput* out, const char* external_dir,
     const char* chunk_template, const char* out_dir) {
   PkgLoadedTree tree;
   size_t i;
   if (pkg_native_load_tree(ctx, data, len, d, out, external_dir, &tree) !=
       DIST_OK)
     return DIST_ERR;
   if (pkg_verify_artifact_overlays(ctx, &v->manifest, out, &tree.tree) !=
       DIST_OK)
     return DIST_ERR;
   for (i = 0; i < tree.tree.n_entries; ++i) {
     const DistTreeEntry* e = &tree.tree.entries[i];
     KitWriter* raww = NULL;
     const uint8_t* rawb;
     size_t rawl;
     if (pkg_native_reconstruct_blob(ctx, data, index_b, index_l, d, e,
                                     external_dir, chunk_template,
                                     &raww) != DIST_OK) {
       kit_ctx_diagf(ctx, "native chunk verification failed: %s", e->path);
       return DIST_ERR;
     }
     rawb = kit_writer_mem_bytes(raww, &rawl);
     if (pkg_verify_blob_bytes(e, rawb, rawl) != DIST_OK) {
       kit_writer_close(raww);
       kit_ctx_diagf(ctx, "blob hash mismatch: %s", e->path);
       return DIST_ERR;
     }
     if (out_dir &&
         pkg_write_output_file(host, ctx, out_dir, e, rawb, rawl) != DIST_OK) {
       kit_writer_close(raww);
       return DIST_ERR;
     }
     kit_writer_close(raww);
   }
   return DIST_OK;
 }
 
 static int pkg_verify_native(const KitContext* ctx, const KitCasHost* host,
                              const KitPkgVerifyOptions* opts, PkgVerified* v) {
   const uint8_t* data = opts->pkg_data;
   size_t len = opts->pkg_len;
   const char* external_dir = opts->external_dir;
   KitFileData index_fd = {0};
   DistKpkg3Header h;
   DistKpkg3Descriptor d;
   char err[128];
   uint8_t desc_keyid[DIST_KEYID_LEN], tree_root[DIST_BLAKE2B_LEN],
       index_root[DIST_BLAKE2B_LEN], content_root[DIST_BLAKE2B_LEN];
   char desc_trusted[DIST_TRUSTED_COMMENT_MAX];
   const DistPackageOutput* def;
   const uint8_t* index_b = NULL;
   size_t index_l = 0;
   const char* chunk_template = NULL;
   size_t oi;
   int rc = DIST_ERR;
   if (dist_kpkg3_read_header(data, len, &h) != DIST_OK ||
       pkg_bounds3(&h, len) != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed native package");
     return DIST_ERR;
   }
   if (pkg_verify_manifest(ctx, data + h.manifest_offset,
                           (size_t)h.manifest_size, data + h.signature_offset,
                           (size_t)h.signature_size, data + h.pubkey_offset,
                           (size_t)h.pubkey_size, opts, v) != DIST_OK)
     return DIST_ERR;
   if (dist_minisig_sig_keyid(data + h.descriptor_signature_offset,
                              (size_t)h.descriptor_signature_size,
                              desc_keyid) != DIST_OK ||
       memcmp(desc_keyid, v->keyid, DIST_KEYID_LEN) != 0) {
     kit_ctx_diagf(ctx, "encoding descriptor signer mismatch");
     return DIST_ERR;
   }
   if (dist_minisig_verify(data + h.descriptor_signature_offset,
                           (size_t)h.descriptor_signature_size,
                           data + h.descriptor_offset, (size_t)h.descriptor_size,
                           v->pk, desc_trusted,
                           sizeof desc_trusted) != DIST_OK) {
     kit_ctx_diagf(ctx, "encoding descriptor signature FAILED");
     return DIST_ERR;
   }
   if (dist_kpkg3_descriptor_parse(data + h.descriptor_offset,
                                   (size_t)h.descriptor_size, &d, err,
                                   sizeof err) != DIST_OK) {
     kit_ctx_diagf(ctx, "encoding descriptor: %s", err);
     return DIST_ERR;
   }
   if (memcmp(d.package_id, v->package_id, DIST_BLAKE2B_LEN) != 0 ||
       d.chunk_size != DIST_KPKG3_CHUNK_SIZE_DEFAULT ||
       d.alignment != DIST_KPKG3_ALIGNMENT ||
       !pkg_range_ok(d.tree_offset, d.tree_size, len) ||
       !pkg_range_ok(d.index_offset, d.index_size, len) ||
       !pkg_range_ok(d.content_offset, d.content_size, len)) {
     kit_ctx_diagf(ctx, "encoding descriptor does not match package layout");
     return DIST_ERR;
   }
   dist_kpkg3_region_root(tree_root, "tree", data + d.tree_offset,
                          (size_t)d.tree_size);
   dist_kpkg3_region_root(content_root, "content", data + d.content_offset,
                          (size_t)d.content_size);
   if (pkg_native_load_index(ctx, data, &d, external_dir, &index_fd, &index_b,
                             &index_l) != DIST_OK) {
     kit_ctx_diagf(ctx, "native package index verification failed");
     goto done;
   }
   dist_kpkg3_region_root(index_root, "index", index_b, index_l);
   if (!pkg_descriptor_has_embedded_chunks(&d))
     chunk_template = pkg_descriptor_chunk_template(&d);
   if (d.index_bytes && !pkg_descriptor_has_embedded_chunks(&d) &&
       !external_dir) {
     kit_ctx_diagf(ctx, "external native chunks are missing");
     goto done;
   }
   if (memcmp(tree_root, d.tree_root, DIST_BLAKE2B_LEN) != 0 ||
       memcmp(index_root, d.index_root, DIST_BLAKE2B_LEN) != 0 ||
       memcmp(content_root, d.content_root, DIST_BLAKE2B_LEN) != 0) {
     kit_ctx_diagf(ctx, "native package region hash mismatch");
     goto done;
   }
   if (pkg_verify_native_index_sorted(index_b, index_l, &d) != DIST_OK) {
     kit_ctx_diagf(ctx, "native chunk index is malformed");
     goto done;
   }
   def = pkg_default_output(&v->manifest);
   if (!def) goto done;
   for (oi = 0; oi < v->manifest.n_outputs; ++oi) {
     const DistPackageOutput* out = &v->manifest.outputs[oi];
     if (pkg_verify_native_tree(host, ctx, data, len, index_b, index_l, &d, v,
                                out, external_dir, chunk_template,
                                out == def ? opts->unpack_dir : NULL) != DIST_OK)
       goto done;
   }
   rc = DIST_OK;
 done:
   if (index_fd.token || index_fd.data)
     ctx->file_io->release(ctx->file_io->user, &index_fd);
   return rc;
 }
 
 /* ---------------------------------------------------------------------- */
 /* public verbs + primitives                                              */
 /* ---------------------------------------------------------------------- */
 
 KitStatus kit_pkg_verify(const KitContext* ctx, const KitCasHost* host,
                          const KitPkgVerifyOptions* opts,
                          KitPkgVerifyResult* result) {
   PkgVerified v;
   int rc;
   if (!ctx || !host || !opts || !result || !opts->pkg_data) return KIT_INVALID;
   if (opts->format == KIT_PKG_FORMAT_TARGZ)
     rc = pkg_verify_portable(ctx, host, opts, &v);
   else
     rc = pkg_verify_native(ctx, host, opts, &v);
   if (rc != DIST_OK) return KIT_ERR;
   memset(result, 0, sizeof *result);
   snprintf(result->name, sizeof result->name, "%s", v.manifest.name);
   snprintf(result->version, sizeof result->version, "%s", v.manifest.version);
   snprintf(result->trusted, sizeof result->trusted, "%s", v.trusted);
   memcpy(result->keyid, v.keyid, DIST_KEYID_LEN);
   result->tofu_pin = v.tofu_pin;
   memcpy(result->tofu_pk, v.pk, DIST_ED25519_PK_LEN);
   return KIT_OK;
 }
 
 KitStatus kit_pkg_inspect(const KitContext* ctx, const uint8_t* pkg_data,
                           size_t pkg_len, KitPkgFormat format,
                           int show_encoding, KitWriter* out) {
   if (!ctx || !pkg_data || !out) return KIT_INVALID;
   if (format == KIT_PKG_FORMAT_TARGZ) {
     KitWriter* inflated = NULL;
     DistTarEntry entries[PKG_MAX_TAR_ENTRIES];
     size_t ne = 0;
     const DistTarEntry* man;
     KitStatus st = KIT_ERR;
     if (pkg_load_portable(ctx, pkg_data, pkg_len, &inflated, entries, &ne) ==
             DIST_OK &&
         (man = pkg_find_name(entries, ne, PKG_META_MANIFEST)) != NULL) {
       if (man->size && kit_writer_write(out, man->data, man->size) != KIT_OK)
         st = KIT_IO;
       else
         st = kit_writer_status(out) == KIT_OK ? KIT_OK : KIT_IO;
     }
     if (inflated) kit_writer_close(inflated);
     return st;
   } else {
     DistKpkg3Header h;
     const uint8_t* region;
     size_t region_len;
     if (dist_kpkg3_read_header(pkg_data, pkg_len, &h) != DIST_OK ||
         pkg_bounds3(&h, pkg_len) != DIST_OK) {
       kit_ctx_diagf(ctx, "malformed native package");
       return KIT_MALFORMED;
     }
     if (show_encoding) {
       region = pkg_data + h.descriptor_offset;
       region_len = (size_t)h.descriptor_size;
     } else {
       region = pkg_data + h.manifest_offset;
       region_len = (size_t)h.manifest_size;
     }
     if (region_len && kit_writer_write(out, region, region_len) != KIT_OK)
       return KIT_IO;
     return kit_writer_status(out) == KIT_OK ? KIT_OK : KIT_IO;
   }
 }
 
 KitStatus kit_release_index_emit(const KitContext* ctx,
                                  const KitReleaseIndex* index, KitWriter* out) {
   char err[128];
   if (!ctx || !index || !out) return KIT_INVALID;
   /* Validate first so an invalid index is reported with a clear reason; the
    * emit re-validates internally but does not surface the message. */
   if (dist_release_index_validate(index, err, sizeof err) != DIST_OK) {
     kit_ctx_diagf(ctx, "%s", err);
     return KIT_ERR;
   }
   if (dist_release_index_emit(index, out) != DIST_OK) {
     if (kit_writer_status(out) != KIT_OK) return KIT_IO;
     kit_ctx_diagf(ctx, "release index emit failed");
     return KIT_ERR;
   }
   return kit_writer_status(out) == KIT_OK ? KIT_OK : KIT_IO;
 }
 
 KitStatus kit_release_index_parse(const KitContext* ctx, const uint8_t* data,
                                   size_t len, KitReleaseIndex* out) {
   char err[128];
   if (!ctx || !data || !out) return KIT_INVALID;
   if (dist_release_index_parse(data, len, out, err, sizeof err) != DIST_OK) {
     kit_ctx_diagf(ctx, "%s", err);
     return KIT_MALFORMED;
   }
   return KIT_OK;
 }
 
 KitStatus kit_calver_compare(const char* a, const char* b, int* cmp) {
   if (!a || !b || !cmp) return KIT_INVALID;
   return dist_calver_compare(a, b, cmp) == DIST_OK ? KIT_OK : KIT_INVALID;
 }
 
 KitStatus kit_pkg_sign_detached(const KitContext* ctx, const uint8_t* msg,
                                 size_t msglen, const uint8_t* seckey_bytes,
                                 size_t seckey_len, const char* comment,
                                 KitWriter* out) {
   uint8_t sk[DIST_ED25519_SK_LEN], keyid[DIST_KEYID_LEN];
   int rc;
   const char* tc = (comment && *comment) ? comment : "kit detached signature";
   if (!ctx || (!msg && msglen) || !seckey_bytes || !out) return KIT_INVALID;
   rc = dist_minisig_parse_seckey(seckey_bytes, seckey_len, sk, keyid);
   if (rc == DIST_ENCRYPTED) {
     kit_ctx_diagf(ctx, "encrypted secret keys need scrypt");
     return KIT_UNSUPPORTED;
   }
   if (rc != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed secret key");
     return KIT_MALFORMED;
   }
   if (dist_minisig_sign(out, msg, msglen, sk, keyid, "kit signature", tc) !=
       DIST_OK) {
     kit_ctx_diagf(ctx, "could not produce signature");
     return KIT_ERR;
   }
   return kit_writer_status(out) == KIT_OK ? KIT_OK : KIT_IO;
 }
 
 KitStatus kit_pkg_verify_detached(
     const KitContext* ctx, const KitPkgDetachedVerifyOptions* opts,
     KitPkgDetachedVerifyResult* result) {
   uint8_t pk[DIST_ED25519_PK_LEN];
   uint8_t keyid_check[DIST_KEYID_LEN];
   if (!ctx || !opts || !result || (!opts->data && opts->data_len) ||
       !opts->signature)
     return KIT_INVALID;
   memset(result, 0, sizeof *result);
   if (dist_minisig_sig_keyid(opts->signature, opts->signature_len,
                              result->keyid) != DIST_OK) {
     kit_ctx_diagf(ctx, "malformed detached signature");
     return KIT_MALFORMED;
   }
   if (opts->pubkey_bytes) {
     if (dist_minisig_parse_pubkey(opts->pubkey_bytes, opts->pubkey_len, pk,
                                   keyid_check) != DIST_OK) {
       kit_ctx_diagf(ctx, "malformed public key");
       return KIT_MALFORMED;
     }
     if (memcmp(keyid_check, result->keyid, DIST_KEYID_LEN) != 0) {
       kit_ctx_diagf(ctx, "public key id does not match detached signature");
       return KIT_ERR;
     }
   } else if (!opts->trusted_keys ||
              dist_trust_lookup(opts->trusted_keys, opts->trusted_keys_len,
                                result->keyid, pk) != DIST_OK) {
     char hex[2 * DIST_KEYID_LEN + 1];
     dist_hex_encode(hex, result->keyid, DIST_KEYID_LEN);
     kit_ctx_diagf(ctx, "untrusted detached signer (key id %s)", hex);
     return KIT_ERR;
   }
   if (dist_minisig_verify(opts->signature, opts->signature_len, opts->data,
                           opts->data_len, pk, result->trusted,
                           sizeof result->trusted) != DIST_OK) {
     kit_ctx_diagf(ctx, "detached signature verification FAILED");
     return KIT_ERR;
   }
   return KIT_OK;
 }
 
 KitStatus kit_pkg_keygen(const KitContext* ctx, KitPkgRandomFn rng,
                          void* rng_user, KitWriter* pub_out, KitWriter* sec_out,
                          uint8_t out_keyid[KIT_PKG_KEYID_LEN]) {
   uint8_t seed[DIST_ED25519_SEED_LEN], keyid[DIST_KEYID_LEN];
   DistKeypair kp;
   if (!rng || !pub_out || !sec_out) return KIT_INVALID;
   if (rng(rng_user, seed, sizeof seed) != 0 ||
       rng(rng_user, keyid, sizeof keyid) != 0) {
     kit_ctx_diagf(ctx, "keygen: failed to read system randomness");
     return KIT_ERR;
   }
   dist_minisig_keygen(&kp, seed, keyid);
   if (dist_minisig_emit_pubkey(pub_out, &kp) != DIST_OK ||
       kit_writer_status(pub_out) != KIT_OK)
     return KIT_IO;
   if (dist_minisig_emit_seckey(sec_out, &kp) != DIST_OK ||
       kit_writer_status(sec_out) != KIT_OK)
     return KIT_IO;
   if (out_keyid) memcpy(out_keyid, kp.keyid, DIST_KEYID_LEN);
   return KIT_OK;
 }
 
 KitStatus kit_minisig_parse_pubkey(const uint8_t* data, size_t len,
                                    uint8_t pk_out[KIT_PKG_PK_LEN],
                                    uint8_t keyid_out[KIT_PKG_KEYID_LEN]) {
   return dist_minisig_parse_pubkey(data, len, pk_out, keyid_out) == DIST_OK
              ? KIT_OK
              : KIT_MALFORMED;
 }
 
 KitStatus kit_minisig_parse_seckey(const uint8_t* data, size_t len,
                                    uint8_t sk_out[KIT_PKG_SK_LEN],
                                    uint8_t keyid_out[KIT_PKG_KEYID_LEN]) {
   int rc = dist_minisig_parse_seckey(data, len, sk_out, keyid_out);
   if (rc == DIST_OK) return KIT_OK;
   if (rc == DIST_ENCRYPTED) return KIT_UNSUPPORTED;
   return KIT_MALFORMED;
 }
 
 KitStatus kit_trust_lookup(const uint8_t* file, size_t len,
                            const uint8_t keyid[KIT_PKG_KEYID_LEN],
                            uint8_t pk_out[KIT_PKG_PK_LEN]) {
   return dist_trust_lookup(file, len, keyid, pk_out) == DIST_OK ? KIT_OK
                                                                 : KIT_NOT_FOUND;
 }
 
 KitStatus kit_trust_format_entry(char* out, size_t cap,
                                  const uint8_t keyid[KIT_PKG_KEYID_LEN],
                                  const uint8_t pk[KIT_PKG_PK_LEN],
                                  const char* label) {
   return dist_trust_format_entry(out, cap, keyid, pk, label) == DIST_OK
              ? KIT_OK
              : KIT_ERR;
 }