@tinkerlandai/indiana-iam 0.2.0 → 0.4.0

package/src/ui-structure.mjs

@@ -0,0 +1,645 @@
+import { identity, canonical } from "./integrity.mjs";
+import { documentDom } from "./dom-payload.mjs";
+import { JSDOM, VirtualConsole } from "jsdom";
+import { checkedCollectionFragment } from "./source-collections.mjs";
+import {graphSource} from './graph-sources.mjs';
+
+const text = { type: "string", minLength: 1, maxLength: 2048 };
+const nullable = (shape) => ({ anyOf: [shape, { type: "null" }] });
+const array = (items, maxItems = 20000) => ({ type: "array", items, maxItems });
+const object = (properties) => ({
+  type: "object",
+  properties,
+  required: Object.keys(properties),
+  additionalProperties: false,
+});
+const source = object({
+  file: text,
+  symbol: text,
+  line: { type: "integer", minimum: 1 },
+  column: { type: "integer", minimum: 1 },
+  fileHash: { type: "string", pattern: "^[a-f0-9]{64}$" },
+});
+
+/** Inert, source-derived presentation relationships. They never authorize an action. */
+export const uiStructureSchema = object({
+  schemaVersion: { const: 1 },
+  conditions: array(object({ conditionKey: text, expression: text, source })),
+  tabs: array(
+    object({
+      tabKey: text,
+      routeKey: text,
+      renderKey: text,
+      nodeId: text,
+      variableKey: nullable(text),
+      initialValue: nullable(text),
+      items: array(object({ value: text, nodeId: text }), 100),
+      source,
+      scopeSource: source,
+    }),
+  ),
+  navigation: array(
+    object({
+      relationKey: text,
+      routeKey: text,
+      targetRouteKey: text,
+      kind: { enum: ["login", "return", "redirect"] },
+      returnParameter: nullable(text),
+      condition: nullable(text),
+      activation: { enum: ["route-condition", "source-continuation"] },
+      sourceRefs: array(source, 16),
+    }),
+  ),
+});
+
+uiStructureSchema.properties.regions = array(
+  object({
+    regionKey: text,
+    routeKey: text,
+    renderKey: text,
+    nodeId: text,
+    expression: text,
+    variableKey: nullable(text),
+    initialValue: nullable(text),
+    options: array(
+      object({
+        value: text,
+        label: text,
+        nodeId: text,
+        componentKey: text,
+        source,
+        scope: nullable(text),
+      }),
+      32,
+    ),
+    source,
+  }),
+);
+
+uiStructureSchema.properties.tabs.items.properties.scopeNodeId = text;
+uiStructureSchema.properties.tabs.items.properties.contentNodeIds = array(
+  text,
+  2000,
+);
+uiStructureSchema.properties.conditions.items.properties.observation = {
+  enum: ["remote", "unobserved-data"],
+};
+uiStructureSchema.properties.fragments = array(
+  object({
+    fragmentKey: text,
+    html: { type: "string", maxLength: 262144 },
+    elementKeys: array({ type: "integer", minimum: 0, maximum: 1999 }, 2000),
+    sourceElements: array(text, 2000),
+    classNames: array({ type: "string", maxLength: 4000 }, 128),
+    source,
+    itemCount: { type: "integer", minimum: 0, maximum: 128 },
+  }),
+  200,
+);
+uiStructureSchema.properties.collections = array(
+  object({
+    collectionKey: text,
+    routeKey: text,
+    renderKey: text,
+    nodeId: text,
+    variableKey: text,
+    requires: array(
+      object({
+        variableKey: text,
+        value: { type: ["string", "number", "boolean"] },
+      }),
+      16,
+    ),
+    cases: array(object({ value: text, fragmentKey: text }), 8),
+    source,
+  }),
+  1000,
+);
+
+uiStructureSchema.properties.attributeSets = array(
+  object({
+    setKey: text,
+    property: { enum: ["class", "placeholder", "aria-label"] },
+    cases: array(
+      object({ value: text, text: { type: "string", maxLength: 4000 } }),
+      8,
+    ),
+    source,
+  }),
+  500,
+);
+uiStructureSchema.properties.attributes = array(
+  object({
+    attributeKey: text,
+    routeKey: text,
+    renderKey: text,
+    nodeId: text,
+    variableKey: text,
+    setKey: text,
+  }),
+  2000,
+);
+
+export function attachUiStructure(graph, structure, documents) {
+  const nodeRenders = new Map(
+    documents.flatMap((d) =>
+      d.nodes.map((n) => [
+        n.nodeId,
+        graph.renders.find((r) => r.documentKey === d.documentKey)?.renderKey,
+      ]),
+    ),
+  );
+  // Conditions and adapted primitives can be synthetic and therefore are not SDK targets.
+  for (const row of [
+    ...structure.tabs,
+    ...(structure.regions ?? []),
+    ...(structure.collections ?? []),
+    ...(structure.attributes ?? []),
+  ])
+    row.renderKey = nodeRenders.get(row.truthyNodeId ?? row.nodeId);
+  const allNodes = new Map(
+    documents.flatMap((d) => d.nodes.map((n) => [n.nodeId, n])),
+  );
+  const within = (id, root) => {
+    let n = allNodes.get(id),
+      count = 0;
+    while (n && count++ < 128) {
+      if (n.nodeId === root) return true;
+      n = allNodes.get(n.parentId);
+    }
+    return false;
+  };
+  const reads = (expr, key) =>
+    (expr?.op === "var" && expr.key === key) ||
+    [
+      expr?.arg,
+      expr?.left,
+      expr?.right,
+      ...(expr?.args ?? []),
+      ...(expr?.parts ?? []).map((p) => p.when),
+    ].some((e) => e && reads(e, key));
+  for (const tab of structure.tabs) {
+    const chain = [];
+    let n = allNodes.get(tab.nodeId);
+    while (n && chain.length < 128) {
+      chain.push(n);
+      n = allNodes.get(n.parentId);
+    }
+    const local = chain.filter(
+      (n) =>
+        n.source.file === tab.scopeSource.file &&
+        n.source.symbol === tab.scopeSource.symbol,
+    );
+    tab.scopeNodeId =
+      chain.find((n) => n.attributes.role === "dialog")?.nodeId ??
+      local.at(-1)?.nodeId ??
+      tab.nodeId;
+    tab.contentNodeIds = [
+      ...new Set(
+        graph.bindings
+          .filter(
+            (b) =>
+              b.renderKey === tab.renderKey &&
+              tab.variableKey &&
+              reads(b.value, tab.variableKey) &&
+              within(b.nodeId, tab.scopeNodeId) &&
+              !within(b.nodeId, tab.nodeId),
+          )
+          .map((b) => b.nodeId),
+      ),
+    ];
+  }
+  const {
+    conditions,
+    tabs,
+    navigation,
+    regions = [],
+    collections = [],
+    fragments = [],
+    attributes = [],
+    attributeSets = [],
+  } = structure;
+  // Analysis can visit JSX that a parent adapter does not project. Only the
+  // conditions attached to final concrete containers belong to this graph.
+  const projectedConditions = new Set();
+  for (const document of documents) {
+    const dom = new JSDOM(document.html, {
+      virtualConsole: new VirtualConsole(),
+    });
+    try {
+      for (const node of dom.window.document.querySelectorAll(
+        "[data-iam-condition]",
+      ))
+        projectedConditions.add(node.getAttribute("data-iam-condition"));
+    } finally {
+      dom.window.close();
+    }
+  }
+  return {
+    ...graph,
+    ui: {
+      schemaVersion: 1,
+      conditions: conditions.filter((c) =>
+        projectedConditions.has(c.conditionKey),
+      ),
+      tabs,
+      navigation,
+      regions,
+      collections,
+      fragments,
+      attributes,
+      attributeSets,
+    },
+  };
+}
+
+export function validateUiStructure(graph, manifest, documents) {
+  if (!graph.ui) return;
+  const nodes = new Map(
+    documents.flatMap((d) =>
+      d.nodes.map((n) => [
+        n.nodeId,
+        { ...n, pageKey: d.pageKey, documentKey: d.documentKey },
+      ]),
+    ),
+  );
+  const renders = new Map(graph.renders.map((r) => [r.renderKey, r]));
+  const sourceCheck = (s) => {
+    if (
+      !manifest.sourceFiles.some(
+        (f) => f.file === s.file && f.sha256 === s.fileHash,
+      )
+    )
+      throw Error("UI structure source mismatch");
+  };
+  const seen = new Set();
+  function own(row, nodeId) {
+    const node = nodes.get(nodeId),
+      render = renders.get(row.renderKey);
+    if (
+      !node ||
+      !render ||
+      node.pageKey !== row.routeKey ||
+      render.routeKey !== row.routeKey ||
+      node.documentKey !== render.documentKey
+    )
+      throw Error("UI structure DOM scope mismatch");
+    return node;
+  }
+  const within = (id, root) => {
+    let node = nodes.get(id),
+      count = 0;
+    while (node && count++ < 128) {
+      if (node.nodeId === root) return true;
+      node = nodes.get(node.parentId);
+    }
+    return false;
+  };
+  for (const row of graph.ui.conditions) {
+    if (seen.has(row.conditionKey)) throw Error("Duplicate UI condition");
+    seen.add(row.conditionKey);
+    sourceCheck(row.source);
+  }
+  const conditions = new Map(
+      graph.ui.conditions.map((c) => [c.conditionKey, c]),
+    ),
+    usedConditions = new Set(),
+    regionMarkers = new Map();
+  for (const document of documents) {
+    const dom = new JSDOM(
+      documentDom(
+        manifest.documents.find((d) => d.documentKey === document.documentKey),
+      ).html,
+      { virtualConsole: new VirtualConsole() },
+    );
+    try {
+      for (const node of dom.window.document.querySelectorAll(
+        "[data-iam-region],[data-iam-region-value],[data-iam-collection]",
+      ))
+        regionMarkers.set(node.getAttribute("data-iam-node"), {
+          key: node.getAttribute("data-iam-region"),
+          value: node.getAttribute("data-iam-region-value"),
+          collection: node.getAttribute("data-iam-collection"),
+        });
+      for (const node of dom.window.document.querySelectorAll(
+        "[data-iam-condition]",
+      )) {
+        const key = node.getAttribute("data-iam-condition"),
+          condition = conditions.get(key),
+          id = node.getAttribute("data-iam-node"),
+          mapped = nodes.get(id);
+        if (
+          !condition ||
+          !mapped?.synthetic ||
+          !node.hasAttribute("hidden") ||
+          !["true", "false"].includes(node.getAttribute("data-iam-alternative"))
+        )
+          throw Error(
+            "Invalid source condition container: " +
+              JSON.stringify({
+                key,
+                id,
+                known: !!condition,
+                synthetic: mapped?.synthetic,
+                hidden: node.hasAttribute("hidden"),
+                source: mapped?.source,
+              }),
+          );
+        usedConditions.add(key);
+      }
+    } finally {
+      dom.window.close();
+    }
+  }
+  if (conditions.size !== usedConditions.size)
+    throw Error("Source condition has no concrete UI");
+  const fragments = new Map(),
+    fragmentElements = new Map(manifest.elements.map((e) => [e.elementKey, e]));
+  let fragmentBytes = 0;
+  for (const fragment of graph.ui.fragments ?? []) {
+    const { fragmentKey, ...body } = fragment;
+    sourceCheck(fragment.source);
+    fragmentBytes += Buffer.byteLength(fragment.html);
+    if (
+      fragmentBytes > 1_048_576 ||
+      fragments.has(fragmentKey) ||
+      identity("ui-fragment", body) !== fragmentKey
+    )
+      throw Error("Invalid shared source fragment");
+    const dom = new JSDOM("<body>" + fragment.html + "</body>", {
+      virtualConsole: new VirtualConsole(),
+    });
+    try {
+      const nodes = checkedCollectionFragment(
+        dom.window.document,
+        fragment,
+      ).nodes;
+      if (nodes.length !== fragment.elementKeys.length)
+        throw Error("Shared source fragment mapping mismatch");
+      const allowed = new Set(
+        "div span p button input svg path circle rect line polyline polygon ellipse g title".split(
+          " ",
+        ),
+      );
+      for (const [index, node] of nodes.entries()) {
+        const element = fragmentElements.get(
+          fragment.sourceElements[fragment.elementKeys[index]],
+        );
+        if (
+          !element ||
+          (/^[a-z]/.test(element.tag) &&
+            element.tag !== node.tagName.toLowerCase()) ||
+          !allowed.has(node.tagName.toLowerCase())
+        )
+          throw Error(
+            "Invalid shared source fragment element: " +
+              String(element?.tag) +
+              " / " +
+              node.tagName.toLowerCase() +
+              " / " +
+              fragment.source.file +
+              ":" +
+              fragment.source.line,
+          );
+        sourceCheck(element.source);
+        for (const attr of node.attributes)
+          if (
+            /^on/i.test(attr.name) ||
+            (attr.name.startsWith("data-") && !/^data-(?:slot|state|active|disabled|pressed)$/.test(attr.name)) ||
+            [
+              "id",
+              "href",
+              "src",
+              "srcset",
+              "srcdoc",
+              "action",
+              "formaction",
+              "name",
+              "autofocus",
+            ].includes(attr.name) ||
+            (attr.name === "style" &&
+              /(?:url\(|@import|expression\()/i.test(attr.value))
+          )
+            throw Error("Active shared source fragment attribute");
+      }
+    } finally {
+      dom.window.close();
+    }
+    fragments.set(fragmentKey, fragment);
+  }
+  const usedFragments = new Set();
+  const sets = new Map();
+  for (const set of graph.ui.attributeSets ?? []) {
+    sourceCheck(set.source);
+    const { setKey, ...body } = set;
+    if (
+      sets.has(setKey) ||
+      setKey !== identity("ui-attribute-set", body) ||
+      set.cases.length < 2 ||
+      new Set(set.cases.map((c) => c.value)).size !== set.cases.length
+    )
+      throw Error("Invalid source attribute set");
+    sets.set(setKey, set);
+  }
+  const usedSets = new Set();
+  for (const row of graph.ui.attributes ?? []) {
+    const node = own(row, row.nodeId),
+      set = sets.get(row.setKey),
+      variable = graph.variables.find(
+        (v) =>
+          v.variableKey === row.variableKey && v.renderKey === row.renderKey,
+      );
+    if (
+      !set ||
+      !variable ||
+      !graph.ui.tabs.some(
+        (t) =>
+          t.variableKey === row.variableKey &&
+          set.cases.every((c) => t.items.some((i) => i.value === c.value)),
+      )
+    )
+      throw Error("Source attribute scope mismatch");
+    const source = node.source ?? fragmentElements.get(node.elementKey)?.source;
+    const forwardedWithinTab=graph.ui.tabs.some(t=>t.variableKey===row.variableKey&&t.scopeSource.file===set.source.file&&t.scopeSource.symbol===set.source.symbol&&within(row.nodeId,t.scopeNodeId??t.nodeId));
+    if ((source.file !== set.source.file || source.symbol !== set.source.symbol)&&!forwardedWithinTab)
+      throw Error("Source attribute owner mismatch");
+    if (seen.has(row.attributeKey)) throw Error("Duplicate source attribute");
+    seen.add(row.attributeKey);
+    usedSets.add(row.setKey);
+  }
+  if (usedSets.size !== sets.size) throw Error("Unused source attribute set");
+  for (const row of graph.ui.collections ?? []) {
+    if (seen.has(row.collectionKey)) throw Error("Duplicate source collection");
+    seen.add(row.collectionKey);
+    sourceCheck(row.source);
+    const root = own(row, row.nodeId);
+    if (
+      !root.synthetic ||
+      !Object.hasOwn(root.attributes, "hidden") ||
+      regionMarkers.get(row.nodeId)?.collection !== row.collectionKey
+    )
+      throw Error("Invalid source collection mount");
+    const variable = graph.variables.find(
+      (v) =>
+        v.variableKey === row.variableKey &&
+        v.routeKey === row.routeKey &&
+        v.renderKey === row.renderKey,
+    );
+    if (
+      !variable ||
+      variable.valueType !== "string" ||
+      !graph.ui.tabs.some(
+        (t) =>
+          t.variableKey === row.variableKey && t.renderKey === row.renderKey,
+      )
+    )
+      throw Error("Source collection has no controlled Tab");
+    for (const required of row.requires)
+      if (
+        !graph.variables.some(
+          (v) =>
+            v.variableKey === required.variableKey &&
+            v.routeKey === row.routeKey &&
+            v.renderKey === row.renderKey &&
+            v.valueType === typeof required.value,
+        )
+      )
+        throw Error("Source collection constraint mismatch");
+    const values = new Set();
+    for (const item of row.cases) {
+      if (
+        values.has(item.value) ||
+        !fragments.has(item.fragmentKey) ||
+        !graph.ui.tabs.some(
+          (t) =>
+            t.variableKey === row.variableKey &&
+            t.items.some((i) => i.value === item.value),
+        )
+      )
+        throw Error("Invalid source collection case");
+      values.add(item.value);
+      usedFragments.add(item.fragmentKey);
+    }
+    if (values.size < 2) throw Error("Source collection needs distinct cases");
+  }
+  if (usedFragments.size !== fragments.size)
+    throw Error("Unreferenced shared source fragment");
+  for (const row of graph.ui.tabs) {
+    if (seen.has(row.tabKey)) throw Error("Duplicate UI Tab");
+    seen.add(row.tabKey);
+    sourceCheck(row.source);
+    sourceCheck(row.scopeSource);
+    const root = own(row, row.nodeId);
+    if (
+      canonical(
+        root.source ??
+          manifest.elements.find((e) => e.elementKey === root.elementKey)
+            ?.source,
+      ) !== canonical(row.source)
+    )
+      throw Error("UI Tab source mismatch");
+    if (
+      row.variableKey &&
+      !graph.variables.some(
+        (v) =>
+          v.variableKey === row.variableKey &&
+          v.routeKey === row.routeKey &&
+          v.renderKey === row.renderKey &&
+          canonical(graphSource(graph,v)) === canonical(row.scopeSource),
+      )
+    )
+      throw Error("UI Tab variable scope mismatch");
+    if (row.scopeNodeId) {
+      own(row, row.scopeNodeId);
+      if (!within(row.nodeId, row.scopeNodeId))
+        throw Error("UI Tab scope is not an ancestor");
+    }
+    for (const id of row.contentNodeIds ?? []) {
+      own(row, id);
+      if (!within(id, row.scopeNodeId ?? row.nodeId))
+        throw Error("UI Tab content lies outside its scope");
+    }
+    const values = new Set();
+    for (const item of row.items) {
+      const node = own(row, item.nodeId);
+      if (
+        node.tag !== "button" ||
+        node.attributes.role !== "tab" ||
+        !within(item.nodeId, row.nodeId) ||
+        values.has(item.value)
+      )
+        throw Error("Invalid UI Tab item");
+      values.add(item.value);
+    }
+    if (row.initialValue !== null && !values.has(row.initialValue))
+      throw Error("UI Tab initial value is absent");
+  }
+  for (const region of graph.ui.regions ?? []) {
+    if (seen.has(region.regionKey)) throw Error("Duplicate component region");
+    seen.add(region.regionKey);
+    sourceCheck(region.source);
+    const root = own(region, region.nodeId);
+    if (regionMarkers.get(root.nodeId)?.key !== region.regionKey)
+      throw Error("Source region marker mismatch");
+    if (
+      region.variableKey &&
+      !graph.variables.some(
+        (v) =>
+          v.variableKey === region.variableKey &&
+          v.routeKey === region.routeKey &&
+          v.renderKey === region.renderKey,
+      )
+    )
+      throw Error("Region variable scope mismatch");
+    const values = new Set();
+    for (const option of region.options) {
+      sourceCheck(option.source);
+      const node = own(region, option.nodeId);
+      if (
+        !node.synthetic ||
+        !Object.hasOwn(node.attributes, "hidden") ||
+        node.parentId !== region.nodeId ||
+        regionMarkers.get(node.nodeId)?.value !== option.value ||
+        values.has(option.value) ||
+        !manifest.components.some((c) => c.componentKey === option.componentKey)
+      )
+        throw Error("Invalid source component alternative");
+      values.add(option.value);
+    }
+    if (
+      region.options.length < 2 ||
+      (region.initialValue !== null && !values.has(region.initialValue))
+    )
+      throw Error("Invalid source registry selection");
+  }
+  for (const row of graph.ui.navigation) {
+    if (seen.has(row.relationKey)) throw Error("Duplicate UI navigation");
+    seen.add(row.relationKey);
+    if (
+      !graph.routes.some((r) => r.routeKey === row.routeKey) ||
+      !graph.routes.some((r) => r.routeKey === row.targetRouteKey)
+    )
+      throw Error("UI navigation route mismatch");
+    row.sourceRefs.forEach(sourceCheck);
+    const { relationKey, ...data } = row;
+    if (uiRelation(data).relationKey !== relationKey || !row.sourceRefs.length)
+      throw Error("UI relation identity mismatch");
+    if (
+      row.kind === "login" &&
+      !graph.ui.navigation.some(
+        (r) =>
+          r.kind === "return" &&
+          r.routeKey === row.targetRouteKey &&
+          r.targetRouteKey === row.routeKey &&
+          r.returnParameter === row.returnParameter,
+      )
+    )
+      throw Error("Login return consumer is absent");
+    if (["login", "return"].includes(row.kind) && !row.returnParameter)
+      throw Error("UI return parameter is missing");
+  }
+}
+
+export function uiRelation(row) {
+  return { relationKey: identity("ui-relation", row), ...row };
+}

package/src/upload.mjs

@@ -2,10 +2,13 @@ import { repositoryCommit } from "./git-metadata.mjs";
 import { randomUUID } from "node:crypto";
 
 export const DEFAULT_BASE_URL = "https://tinker.cash";
+/** One App environment can hold several clients (named builds); each has its own current version. */
+export const DEFAULT_CLIENT = "web";
+const CLIENT_KEY = /^[a-z][a-z0-9-]{0,39}$/;
 const SIGNED_UPLOAD_ORIGIN = "https://storage.googleapis.com";
 
-/** The build's upload settings: the key and API origin come from options or the build environment. */
-export function uploadSettings({ apiKey, baseUrl, upload = "production" } = {}, env = process.env) {
+/** The build's upload settings: the key, client and API origin come from options or the build environment. */
+export function uploadSettings({ apiKey, baseUrl, upload = "production", client } = {}, env = process.env) {
   const key = apiKey ?? env.INDIANA_IAM_KEY ?? "";
   const mode = upload === true ? "always" : upload;
   const enabled =
@@ -13,7 +16,13 @@ export function uploadSettings({ apiKey, baseUrl, upload = "production" } = {},
     mode !== false &&
     // On Vercel only production deployments upload; preview builds would keep switching the current version.
     (mode === "always" || !env.VERCEL_ENV || env.VERCEL_ENV === "production");
-  return { enabled, apiKey: key, baseUrl: baseUrl ?? env.INDIANA_IAM_BASE_URL ?? DEFAULT_BASE_URL, missingKey: !key };
+  return {
+    enabled,
+    apiKey: key,
+    baseUrl: baseUrl ?? env.INDIANA_IAM_BASE_URL ?? DEFAULT_BASE_URL,
+    client: client ?? env.INDIANA_IAM_CLIENT ?? DEFAULT_CLIENT,
+    missingKey: !key,
+  };
 }
 
 /** A short version label: the commit being built when the CI or git exposes it. */
@@ -35,19 +44,32 @@ async function failure(response, step) {
 /**
  * Uploads one generated IAM to Indiana: register, PUT the bytes to the server-signed URL,
  * then let the server verify them. The key needs only the app-manifests:write permission;
- * the uploaded (or redeployed) version becomes the App environment's current version.
+ * the uploaded (or redeployed) version becomes its client's current version.
  */
-export async function uploadAppManifest({ serialized, digest, label, apiKey, baseUrl = DEFAULT_BASE_URL, fetch = globalThis.fetch }) {
+export async function uploadAppManifest({
+  serialized,
+  digest,
+  label,
+  client = DEFAULT_CLIENT,
+  apiKey,
+  baseUrl = DEFAULT_BASE_URL,
+  fetch = globalThis.fetch,
+}) {
   if (!apiKey) throw new Error("IAM upload needs a key with the app-manifests:write permission");
   const base = new URL(baseUrl);
   if (base.protocol !== "https:" && !["localhost", "127.0.0.1", "[::1]"].includes(base.hostname))
     throw new Error("IAM upload needs an https Indiana origin");
+  if (!CLIENT_KEY.test(client))
+    throw new Error("IAM client must be 1-40 lowercase letters, digits or hyphens, starting with a letter");
+  // The server checks the stored file declares this same platform before the version becomes current.
+  const platforms = JSON.parse(serialized)?.app?.platforms;
+  if (!Array.isArray(platforms) || platforms.length !== 1) throw new Error("IAM upload needs a manifest for exactly one platform");
   const bytes = Buffer.from(serialized);
   const authorization = { Authorization: "Bearer " + apiKey };
   const registered = await fetch(new URL("/api/iam/versions", base), {
     method: "POST",
     headers: { ...authorization, "Content-Type": "application/json" },
-    body: JSON.stringify({ requestId: randomUUID(), label, sha256: digest, bytes: bytes.byteLength }),
+    body: JSON.stringify({ requestId: randomUUID(), client, platform: platforms[0], label, sha256: digest, bytes: bytes.byteLength }),
     signal: AbortSignal.timeout(60_000),
   });
   if (!registered.ok) throw await failure(registered, "registration");