fix: the registry stores the manifest the engine read

Author: dylan-sutton-chavez

site/src/lib/server/bundle.ts

@@ -1,4 +1,4 @@
-import { unpack } from './engine'
+import { manifestFields, unpack } from './engine'
 
 // The prefix the CLI packs documentation under, which no import can reach.
 const DOCS = '@docs/'
@@ -31,16 +31,7 @@ export function packed(artifact: Uint8Array): Packed {
   const declared = files.get('edge.json')
   if (!declared) throw new Error('That package carries no edge.json, so it has nothing to publish under.')
 
-  let manifest: Record<string, unknown>
-  try {
-    manifest = JSON.parse(text.decode(declared))
-  } catch {
-    throw new Error('The edge.json inside that package is not JSON.')
-  }
-
-  if (manifest == null || typeof manifest !== 'object' || Array.isArray(manifest)) {
-    throw new Error('The edge.json inside that package is not an object.')
-  }
+  const manifest = manifestFields(declared)
 
   return {
     name: manifest.name,

site/src/lib/server/engine.ts

@@ -12,6 +12,7 @@ type Exports = {
   wasm_alloc(size: number): number
   wasm_free(ptr: number, size: number): void
   manifest_check(manifest: number, manifestLen: number, lock: number, lockLen: number, system: number, systemLen: number): number
+  manifest_fields(manifest: number, manifestLen: number): number
   bundle_index(bundle: number, bundleLen: number): number
 }
 
@@ -58,6 +59,13 @@ export function unpack(artifact: Uint8Array): Map<string, Uint8Array> {
   return new Map((answer.files ?? []).map(([path, at, len]) => [path, artifact.subarray(at, at + len)]))
 }
 
+/* The fields a registry stores from a manifest, read by the engine that holds it to the rules, so what is stored is what was checked. */
+export function manifestFields(manifest: Uint8Array): Record<'name' | 'version' | 'description' | 'repository' | 'edge', string | null> {
+  const read = JSON.parse(call([manifest], (e, [at]) => e.manifest_fields(at!, manifest.length)))
+  if (read.error !== undefined) throw new Error(`The edge.json inside that package does not hold, ${read.error}`)
+  return read
+}
+
 /* Holds each manifest a bundle carries to the engine's rules, its lock and its grants, here since Node cannot load the compiler. */
 export function checkManifests(manifests: Record<string, string>, locks: Record<string, string>) {
   for (const [dir, source] of Object.entries(manifests)) {

src/wasm/package.rs

@@ -26,6 +26,33 @@ pub unsafe extern "C" fn manifest_check(m_ptr: *const u8, m_len: u32, l_ptr: *co
     write_out(&checked.err().unwrap_or_default()) as u32
 }
 
+/* The fields a registry stores from the manifest at `ptr`, read as the rules read them, as JSON, or why it is not one. */
+#[unsafe(no_mangle)]
+pub unsafe extern "C" fn manifest_fields(ptr: *const u8, len: u32) -> u32 {
+    let mut out = String::from("{");
+    match parse_manifest(unsafe { safe_bytes(ptr, len) }) {
+        Err(e) => {
+            out.push_str("\"error\":");
+            quote(&mut out, &e);
+        }
+        Ok(m) => {
+            for (i, (key, value)) in [("name", m.name), ("version", m.version), ("description", m.description), ("repository", m.repository), ("edge", m.edge)].into_iter().enumerate() {
+                if i > 0 {
+                    out.push(',');
+                }
+                quote(&mut out, key);
+                out.push(':');
+                match value {
+                    Some(text) => quote(&mut out, &text),
+                    None => out.push_str("null"),
+                }
+            }
+        }
+    }
+    out.push('}');
+    write_out(&out) as u32
+}
+
 /* Where each file of the bundle at `ptr` sits inside it, as JSON, or why it is not a bundle. */
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn bundle_index(ptr: *const u8, len: u32) -> u32 {