@series-inc/rundot-kinetix 0.0.0-bootstrap.0

package/src/kinetix-baker.mjs

@@ -0,0 +1,587 @@
+import {
+  kinetixEnvelopeDigest,
+  stableKinetixEnvelopeBytes,
+  validateKinetixEnvelope,
+} from './shared/kinetix-envelope-v1.mjs';
+import {
+  assertKinetixProductContract,
+  assertKinetixRuntimeContract,
+  deriveKinetixRuntimeIdentity,
+  digestKinetixBytes,
+  stableKinetixContractBytes,
+} from './kinetix-product-contract.mjs';
+import { kinetixRuntimeContractForProfile } from './kinetix-installed-systems.mjs';
+
+export const kinetixBakerVersion = 'rundot.kinetix-baker.v1';
+
+export function scanKinetixPayloadTree(value) {
+  const seen = new Set();
+  let scanned = 0;
+  function visit(entry, path) {
+    if (entry instanceof Uint8Array) {
+      scanned += 1;
+      const bytes = Buffer.from(entry);
+      if (bytes.subarray(0, 4).equals(Buffer.from([0x00, 0x61, 0x73, 0x6d]))) throw new Error(`KINETIX_PROHIBITED_WASM ${path}`);
+      if (bytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46]))
+        || bytes.subarray(0, 2).equals(Buffer.from([0x4d, 0x5a]))
+        || ['feedface', 'feedfacf', 'cefaedfe', 'cffaedfe'].includes(bytes.subarray(0, 4).toString('hex'))) {
+        throw new Error(`KINETIX_PROHIBITED_EXECUTABLE ${path}`);
+      }
+      return;
+    }
+    if (typeof entry === 'string') {
+      if (['eval(', 'new Function', 'gl_Position', 'gl_FragColor', 'kernel void'].some((signature) => entry.includes(signature))) {
+        throw new Error(`KINETIX_PROHIBITED_SOURCE ${path}`);
+      }
+      return;
+    }
+    if (entry === null || typeof entry !== 'object') return;
+    if (seen.has(entry)) throw new Error(`KINETIX_PAYLOAD_CYCLE ${path}`);
+    seen.add(entry);
+    if (Array.isArray(entry)) {
+      entry.forEach((item, index) => visit(item, `${path}[${index}]`));
+      seen.delete(entry);
+      return;
+    }
+    for (const [key, item] of Object.entries(entry)) {
+      if (/(?:script|shader|bytecode|wasm|executable)/iu.test(key)) throw new Error(`KINETIX_PROHIBITED_FIELD ${path}.${key}`);
+      if (typeof item === 'string' && /(?:binary|bytesBase64)$/iu.test(key)) {
+        const decoded = Buffer.from(item, 'base64');
+        if (decoded.length === 0 || decoded.toString('base64').replace(/=+$/u, '') !== item.replace(/=+$/u, '')) {
+          throw new Error(`KINETIX_BINARY_ENCODING_INVALID ${path}.${key}`);
+        }
+        visit(decoded, `${path}.${key}`);
+        continue;
+      }
+      visit(item, `${path}.${key}`);
+    }
+    seen.delete(entry);
+  }
+  visit(value, '$');
+  return { scanned };
+}
+export const kinetixPhases = Object.freeze([
+  'initialization',
+  'fixed-simulation',
+  'post-simulation',
+  'presentation-projection',
+  'presentation',
+]);
+
+const structuralCommandKinds = Object.freeze(['spawnPrefab', 'despawnPrefab', 'setEnabled']);
+const authoritativePhases = new Set(['initialization', 'fixed-simulation', 'post-simulation']);
+const presentationPhases = new Set(['presentation-projection', 'presentation']);
+
+function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function addDiagnostic(diagnostics, code, path) {
+  if (!diagnostics.some((entry) => entry.code === code && entry.path === path)) {
+    diagnostics.push({ code, path });
+  }
+}
+
+function stableBytes(value) {
+  return stableKinetixContractBytes(value);
+}
+
+function digestBytes(bytes) {
+  return digestKinetixBytes(bytes);
+}
+
+function validateStringArray(value, path, diagnostics) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_QUERY_INVALID', path);
+    return [];
+  }
+  return value;
+}
+
+function validateSystem(profile, system, path, diagnostics) {
+  if (!isPlainObject(system) || typeof system.id !== 'string' || system.id.length === 0
+    || !Number.isSafeInteger(system.version) || system.version < 1) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_INVALID', path);
+    return;
+  }
+  if (!kinetixPhases.includes(system.phase)) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_PHASE_INVALID', `${path}.phase`);
+  }
+  if (!Number.isSafeInteger(system.order) || system.order < 0) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ORDER_INVALID', `${path}.order`);
+  }
+  if (!isPlainObject(system.query)) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_QUERY_INVALID', `${path}.query`);
+    return;
+  }
+  const all = validateStringArray(system.query.all, `${path}.query.all`, diagnostics);
+  const none = validateStringArray(system.query.none, `${path}.query.none`, diagnostics);
+  if (all.some((type) => none.includes(type))) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_QUERY_CONTRADICTION', `${path}.query`);
+  }
+  for (const [accessKind, accesses] of [['reads', system.reads], ['writes', system.writes]]) {
+    if (!Array.isArray(accesses)) {
+      addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ACCESS_INVALID', `${path}.${accessKind}`);
+      continue;
+    }
+    accesses.forEach((access, index) => {
+      const accessPath = `${path}.${accessKind}[${index}]`;
+      const schema = isPlainObject(access) ? profile.componentSchemas.get(access.type) : null;
+      if (!schema || !schema.domains.includes(access.domain) || !all.includes(access.type)) {
+        addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ACCESS_INVALID', accessPath);
+      }
+      if (accessKind === 'reads' && authoritativePhases.has(system.phase) && access?.domain === 'presentation') {
+        addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ACCESS_INVALID', accessPath);
+      }
+      if (accessKind === 'writes' && presentationPhases.has(system.phase) && access?.domain === 'simulation') {
+        addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ACCESS_INVALID', accessPath);
+      }
+    });
+  }
+  if (!Array.isArray(system.structuralCommands)
+    || system.structuralCommands.some((kind) => !structuralCommandKinds.includes(kind))) {
+    addDiagnostic(diagnostics, 'KINETIX_SYSTEM_COMMAND_INVALID', `${path}.structuralCommands`);
+  }
+}
+
+export function validateInstalledKinetixProfile(profileId, profile) {
+  const diagnostics = [];
+  const path = `$.installedProfiles.${profileId}`;
+  if (!isPlainObject(profile) || typeof profile.abi !== 'string' || profile.abi.length === 0) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_INVALID', path);
+    return { valid: false, diagnostics };
+  }
+  if (!(profile.componentSchemas instanceof Map)) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_INVALID', `${path}.componentSchemas`);
+    return { valid: false, diagnostics };
+  }
+  try {
+    assertKinetixRuntimeContract(profile.runtimeContract);
+  } catch {
+    addDiagnostic(diagnostics, 'KINETIX_RUNTIME_CONTRACT_INVALID', `${path}.runtimeContract`);
+  }
+  for (const [type, schema] of profile.componentSchemas) {
+    const schemaPath = `${path}.componentSchemas.${type}`;
+    if (typeof type !== 'string' || !isPlainObject(schema)
+      || !Number.isSafeInteger(schema.currentSchemaVersion) || schema.currentSchemaVersion < 1
+      || !Array.isArray(schema.domains) || schema.domains.some((domain) => !['simulation', 'presentation', 'binding'].includes(domain))
+      || typeof schema.validate !== 'function') {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_SCHEMA_INVALID', schemaPath);
+    }
+  }
+  if (typeof profile.bakeEntity !== 'function' || typeof profile.bakePrefab !== 'function') {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_INVALID', path);
+  }
+  if (!Array.isArray(profile.systems)) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_INVALID', `${path}.systems`);
+  } else {
+    const ids = new Set();
+    const orders = new Set();
+    profile.systems.forEach((system, index) => {
+      const systemPath = `${path}.systems[${index}]`;
+      validateSystem(profile, system, systemPath, diagnostics);
+      if (isPlainObject(system)) {
+        if (ids.has(system.id)) {
+          addDiagnostic(diagnostics, 'KINETIX_SYSTEM_DUPLICATE', `${systemPath}.id`);
+        }
+        ids.add(system.id);
+        const orderKey = `${system.phase}:${system.order}`;
+        if (orders.has(orderKey)) {
+          addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ORDER_DUPLICATE', `${systemPath}.order`);
+        }
+        orders.add(orderKey);
+      }
+    });
+  }
+  if (profile.transformSemantics !== undefined) {
+    const transform = profile.transformSemantics;
+    if (!isPlainObject(transform) || typeof transform.localType !== 'string'
+      || typeof transform.presentationType !== 'string' || typeof transform.composeWorld !== 'function') {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_TRANSFORM_INVALID', `${path}.transformSemantics`);
+    }
+  }
+  return { valid: diagnostics.length === 0, diagnostics };
+}
+
+function validateAuthoredComponent(component, path, profile, diagnostics) {
+  const schema = profile.componentSchemas.get(component.type);
+  if (!schema) {
+    addDiagnostic(diagnostics, 'KINETIX_COMPONENT_UNKNOWN', `${path}.type`);
+    return;
+  }
+  if (component.schemaVersion !== schema.currentSchemaVersion) {
+    addDiagnostic(diagnostics, 'KINETIX_SCHEMA_VERSION_UNSUPPORTED', `${path}.schemaVersion`);
+  }
+  if (!schema.domains.includes(component.domain)) {
+    addDiagnostic(diagnostics, 'KINETIX_COMPONENT_DOMAIN_INVALID', `${path}.domain`);
+  }
+  const propertyDiagnostics = schema.validate(component.properties, { path });
+  if (!Array.isArray(propertyDiagnostics)) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_SCHEMA_INVALID', `${path}.properties`);
+    return;
+  }
+  for (const diagnostic of propertyDiagnostics) {
+    if (!isPlainObject(diagnostic) || typeof diagnostic.code !== 'string') {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_SCHEMA_INVALID', `${path}.properties`);
+    } else {
+      addDiagnostic(diagnostics, diagnostic.code, diagnostic.path ?? `${path}.properties`);
+    }
+  }
+}
+
+function validateCallbackOutput(output, path, diagnostics) {
+  if (!isPlainObject(output)) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_OUTPUT_INVALID', path);
+    return false;
+  }
+  for (const domain of ['simulation', 'presentation', 'binding']) {
+    if (!Array.isArray(output[domain]) || output[domain].some((record) => !isPlainObject(record))) {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_OUTPUT_INVALID', `${path}.${domain}`);
+    }
+  }
+  for (const key of Object.keys(output)) {
+    if (!['simulation', 'presentation', 'binding'].includes(key)) {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_OUTPUT_INVALID', `${path}.${key}`);
+    }
+  }
+  return diagnostics.length === 0;
+}
+
+function componentSignature(components) {
+  return components
+    .map((component) => [component.type, component.schemaVersion, component.domain])
+    .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+}
+
+function topologicalParentEdges(entities, resolveIndex) {
+  const byId = new Map(entities.map((entity, index) => [entity.id, { entity, index }]));
+  const visited = new Set();
+  const edges = [];
+  function visit(id) {
+    if (visited.has(id)) {
+      return;
+    }
+    const current = byId.get(id);
+    const parentId = current?.entity.parent?.id;
+    if (parentId !== undefined) {
+      visit(parentId);
+      edges.push({ childIndex: resolveIndex(current.index), parentIndex: resolveIndex(byId.get(parentId).index) });
+    }
+    visited.add(id);
+  }
+  entities.forEach((entity) => visit(entity.id));
+  return edges;
+}
+
+function addComponentRecords(payloads, components, source) {
+  components.forEach((component) => {
+    payloads[component.domain].records.push({
+      kind: 'component',
+      source,
+      component: structuredClone(component),
+    });
+  });
+}
+
+function addCallbackRecords(payloads, output, source) {
+  for (const domain of ['simulation', 'presentation', 'binding']) {
+    output[domain].forEach((record) => payloads[domain].records.push({ ...structuredClone(record), source }));
+  }
+}
+
+function archetypeFor(components, archetypeState) {
+  const signature = componentSignature(components);
+  const signatureBytes = stableBytes(signature);
+  const signatureKey = signatureBytes.toString('utf8');
+  if (!archetypeState.bySignature.has(signatureKey)) {
+    const id = `archetype-${digestBytes(signatureBytes).slice(0, 16)}`;
+    archetypeState.bySignature.set(signatureKey, id);
+    archetypeState.entries.push({ id, signature });
+  }
+  return archetypeState.bySignature.get(signatureKey);
+}
+
+function invalidResult(diagnostics) {
+  return { valid: false, diagnostics, products: null, runtimeIdentity: null };
+}
+
+export function bakeKinetixEnvelope(envelope, installedProfiles) {
+  const envelopeResult = validateKinetixEnvelope(envelope);
+  if (!envelopeResult.valid) {
+    return invalidResult(envelopeResult.diagnostics);
+  }
+  const diagnostics = [];
+  if (!(installedProfiles instanceof Map)) {
+    addDiagnostic(diagnostics, 'KINETIX_PROFILE_INVALID', '$.installedProfiles');
+    return invalidResult(diagnostics);
+  }
+  for (const declaration of envelope.profiles) {
+    const profile = installedProfiles.get(declaration.id);
+    if (!profile) {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_NOT_INSTALLED', `$.profiles.${declaration.id}`);
+      continue;
+    }
+    const profileResult = validateInstalledKinetixProfile(declaration.id, profile);
+    diagnostics.push(...profileResult.diagnostics);
+    if (profile.abi !== declaration.abi) {
+      addDiagnostic(diagnostics, 'KINETIX_PROFILE_ABI_MISMATCH', `$.profiles.${declaration.id}.abi`);
+    }
+  }
+
+  const systemIds = new Set();
+  const systemOrders = new Set();
+  for (const declaration of envelope.profiles) {
+    const profile = installedProfiles.get(declaration.id);
+    for (const [index, system] of (profile?.systems ?? []).entries()) {
+      const path = `$.installedProfiles.${declaration.id}.systems[${index}]`;
+      if (systemIds.has(system.id)) {
+        addDiagnostic(diagnostics, 'KINETIX_SYSTEM_DUPLICATE', `${path}.id`);
+      }
+      systemIds.add(system.id);
+      const orderKey = `${system.phase}:${system.order}`;
+      if (systemOrders.has(orderKey)) {
+        addDiagnostic(diagnostics, 'KINETIX_SYSTEM_ORDER_DUPLICATE', `${path}.order`);
+      }
+      systemOrders.add(orderKey);
+    }
+  }
+
+  const authoredOwners = [
+    ...envelope.entities.map((entity, index) => ({ entity, path: `$.entities[${index}]`, profileId: entity.profile })),
+    ...envelope.prefabs.flatMap((prefab, prefabIndex) => prefab.entities.map((entity, entityIndex) => ({
+      entity,
+      path: `$.prefabs[${prefabIndex}].entities[${entityIndex}]`,
+      profileId: prefab.profile,
+    }))),
+  ];
+  for (const owner of authoredOwners) {
+    const profile = installedProfiles.get(owner.profileId);
+    if (!profile) {
+      continue;
+    }
+    owner.entity.components.forEach((component, index) => {
+      validateAuthoredComponent(component, `${owner.path}.components[${index}]`, profile, diagnostics);
+    });
+  }
+  if (diagnostics.length > 0) {
+    return invalidResult(diagnostics);
+  }
+
+  const payloads = {
+    simulation: { records: [], sourceIndex: [] },
+    presentation: { records: [], sourceIndex: [] },
+    binding: { records: [], sourceIndex: [] },
+  };
+  const callbackOutputs = [];
+  envelope.entities.forEach((entity, index) => {
+    const output = installedProfiles.get(entity.profile).bakeEntity({ entity: structuredClone(entity) });
+    callbackOutputs.push({ output, path: `$.entities[${index}]`, source: { kind: 'entity', id: entity.id } });
+  });
+  envelope.prefabs.forEach((prefab, index) => {
+    const output = installedProfiles.get(prefab.profile).bakePrefab({ prefab: structuredClone(prefab) });
+    callbackOutputs.push({ output, path: `$.prefabs[${index}]`, source: { kind: 'prefab', id: prefab.id } });
+  });
+  for (const entry of callbackOutputs) {
+    validateCallbackOutput(entry.output, `${entry.path}.output`, diagnostics);
+  }
+  if (diagnostics.length > 0) {
+    return invalidResult(diagnostics);
+  }
+
+  const archetypeState = { bySignature: new Map(), entries: [] };
+  const directEntities = envelope.entities.map((entity, index) => {
+    const source = { kind: 'entity', id: entity.id };
+    addComponentRecords(payloads, entity.components, source);
+    addCallbackRecords(payloads, callbackOutputs[index].output, source);
+    return {
+      index,
+      sourceId: entity.id,
+      section: entity.section,
+      profile: entity.profile,
+      archetypeId: archetypeFor(entity.components, archetypeState),
+      enabled: entity.enabled ?? true,
+    };
+  });
+
+  const prefabCallbackOffset = envelope.entities.length;
+  const prefabs = envelope.prefabs.map((prefab, prefabIndex) => {
+    const source = { kind: 'prefab', id: prefab.id };
+    prefab.entities.forEach((entity) => addComponentRecords(payloads, entity.components, {
+      kind: 'prefab-local-entity',
+      prefabId: prefab.id,
+      id: entity.id,
+    }));
+    addCallbackRecords(payloads, callbackOutputs[prefabCallbackOffset + prefabIndex].output, source);
+    return {
+      id: prefab.id,
+      profile: prefab.profile,
+      rootLocalEntityId: prefab.rootLocalEntityId,
+      poolBudget: prefab.poolBudget,
+      entities: prefab.entities.map((entity, index) => ({
+        localEntityId: entity.id,
+        localIndex: index,
+        archetypeId: archetypeFor(entity.components, archetypeState),
+        enabled: entity.enabled ?? true,
+      })),
+      parentEdges: topologicalParentEdges(prefab.entities, (index) => index)
+        .map((edge) => ({ childLocalIndex: edge.childIndex, parentLocalIndex: edge.parentIndex })),
+    };
+  });
+
+  for (const domain of ['simulation', 'presentation', 'binding']) {
+    payloads[domain].sourceIndex = payloads[domain].records.map((record, index) => ({ index, source: record.source }));
+  }
+  const budgetByDomain = {
+    simulation: envelope.budgets.maxSimulationRecords,
+    presentation: envelope.budgets.maxPresentationRecords,
+    binding: envelope.budgets.maxBindingRecords,
+  };
+  for (const domain of ['simulation', 'presentation', 'binding']) {
+    if (payloads[domain].records.length > budgetByDomain[domain]) {
+      addDiagnostic(diagnostics, 'KINETIX_OUTPUT_BUDGET_EXCEEDED', `$.budgets.max${domain[0].toUpperCase()}${domain.slice(1)}Records`);
+    }
+  }
+  if (diagnostics.length > 0) {
+    return invalidResult(diagnostics);
+  }
+
+  const systems = envelope.profiles
+    .flatMap((declaration) => installedProfiles.get(declaration.id).systems.map((system) => ({
+      ...structuredClone(system),
+      profileId: declaration.id,
+      phaseIndex: kinetixPhases.indexOf(system.phase),
+    })))
+    .sort((left, right) => left.phaseIndex - right.phaseIndex || left.order - right.order);
+  const sections = [...new Set(envelope.entities.map((entity) => entity.section))]
+    .sort((left, right) => left - right)
+    .map((section) => ({
+      section,
+      entityIndices: directEntities.filter((entity) => entity.section === section).map((entity) => entity.index),
+    }));
+  const parentEdges = topologicalParentEdges(envelope.entities, (index) => index);
+  const payloadTable = ['simulation', 'presentation', 'binding'].map((name) => {
+    const bytes = stableBytes(payloads[name]);
+    return { name, digest: digestBytes(bytes), byteLength: bytes.length };
+  });
+  const runtime = structuredClone(
+    installedProfiles.get(envelope.profiles[0].id).runtimeContract,
+  );
+  const manifest = {
+    sceneId: envelope.sceneId,
+    runtime,
+    sections,
+    directEntities,
+    parentEdges,
+    prefabs,
+    archetypes: archetypeState.entries,
+    systems,
+    payloads: payloadTable,
+    budgets: {
+      maxLiveRuntimeEntities: envelope.budgets.maxLiveRuntimeEntities,
+      maxCommandsPerTick: envelope.budgets.maxCommandsPerTick,
+      prefabs: prefabs.map((prefab) => ({ prefabId: prefab.id, poolBudget: prefab.poolBudget })),
+    },
+    dependencies: {
+      bakerVersion: kinetixBakerVersion,
+      profiles: envelope.profiles.map((profile) => ({ ...profile })),
+      assets: envelope.assets.map((asset) => ({ id: asset.id, digest: asset.sha256, sourceDigest: asset.sourceSha256 })),
+      scenes: envelope.sceneDependencies.map((scene) => ({ id: scene.id, digest: scene.sha256 })),
+    },
+    sourceIndex: directEntities.map((entity) => ({ index: entity.index, sourceId: entity.sourceId })),
+  };
+  const products = {
+    sourceDigest: kinetixEnvelopeDigest(envelope),
+    manifest,
+    simulation: payloads.simulation,
+    presentation: payloads.presentation,
+    binding: payloads.binding,
+  };
+  assertKinetixProductContract(products);
+  return {
+    valid: true,
+    diagnostics: [],
+    products,
+    runtimeIdentity: deriveKinetixRuntimeIdentity(products, runtime),
+  };
+}
+
+export function stableKinetixProductBytes(products) {
+  if (!isPlainObject(products)) {
+    throw new Error('KINETIX_PRODUCTS_INVALID');
+  }
+  return stableBytes(products);
+}
+
+export function stableKinetixSourceBytes(envelope) {
+  return stableKinetixEnvelopeBytes(envelope);
+}
+
+export function bakeKinetixProjectDefinition(project) {
+  const baseRuntime = kinetixRuntimeContractForProfile(project.installedProfile);
+  const sessionSchemaDigest = digestKinetixBytes(stableKinetixContractBytes(project.sessionConfigSchema));
+  const runtime = {
+    ...baseRuntime,
+    tickRate: project.tickRate,
+    inputSchema: structuredClone(project.inputSchema),
+  };
+  const simulation = {
+    format: 'rundot.kinetix-authored-simulation.v1',
+    installedProfile: project.installedProfile,
+    mechanics: structuredClone(project.mechanics),
+    components: structuredClone(project.components),
+    systems: structuredClone(project.systems),
+  };
+  const presentation = {
+    format: 'rundot.kinetix-authored-presentation.v1',
+    bindings: structuredClone(project.presentationBindings),
+  };
+  const binding = {
+    format: 'rundot.kinetix-authored-binding.v1',
+    projectId: project.id,
+  };
+  const payloads = { simulation, presentation, binding };
+  const payloadTable = ['simulation', 'presentation', 'binding'].map((name) => {
+    const bytes = stableKinetixContractBytes(payloads[name]);
+    return { name, digest: digestKinetixBytes(bytes), byteLength: bytes.length };
+  });
+  const sourceContract = {
+    format: 'rundot.kinetix-authoring-source.v1',
+    projectId: project.id,
+    installedProfile: project.installedProfile,
+    tickRate: project.tickRate,
+    inputSchema: project.inputSchema,
+    sessionConfigSchemaId: project.sessionConfigSchema.id,
+    sessionConfigSchemaDigest: sessionSchemaDigest,
+    mechanics: project.mechanics,
+    components: project.components,
+    systems: project.systems,
+    presentationBindings: project.presentationBindings,
+  };
+  const products = {
+    sourceDigest: digestKinetixBytes(stableKinetixContractBytes(sourceContract)),
+    manifest: {
+      sceneId: project.id,
+      runtime,
+      sessionConfig: {
+        schemaId: project.sessionConfigSchema.id,
+        schemaDigest: sessionSchemaDigest,
+        maxBytes: project.sessionConfigSchema.maxBytes,
+      },
+      payloads: payloadTable,
+    },
+    ...payloads,
+  };
+  assertKinetixProductContract(products);
+  const bytes = stableKinetixContractBytes(products);
+  return {
+    products,
+    runtimeIdentity: deriveKinetixRuntimeIdentity(products, runtime),
+    contentDigest: digestKinetixBytes(bytes),
+  };
+}
+
+export {
+  assertKinetixProductContract,
+  assertKinetixRuntimeIdentityMatchesProducts,
+  deriveKinetixRuntimeIdentity,
+} from './kinetix-product-contract.mjs';