@instruktlabs/kiln 1.2.1 → 1.2.3

package/src/procedural-texture.ts

@@ -38,15 +38,12 @@
  */
 
 import * as THREE from 'three';
+import { compileProceduralTextureSpecV2 } from './procedural-texture-v2-compiler';
+import { compileProceduralTextureSpecV3 } from './procedural-texture-v3';
+import type { ProceduralTextureSpecV3 } from './procedural-texture-v3';
 import {
-  type CanonicalProceduralLayerV2,
-  type CanonicalProceduralTextureSpecV2,
-  type ProceduralBlend,
-  type ProceduralTextureSpec,
+  type ProceduralTextureSpec as LegacyProceduralTextureSpec,
   ProceduralTextureError,
-  canonicalProceduralTextureJsonV2,
-  canonicalizeProceduralTextureSpecV2,
-  hashProceduralTextureSpecV2,
 } from './procedural-material-v2';
 
 export {
@@ -76,237 +73,72 @@ export type {
   PortableTextureRefV2,
   ProceduralBlend,
   ProceduralLayer,
-  ProceduralTextureSpec,
   ProceduralTextureSpecV1,
   ProceduralTextureSpecV2,
 } from './procedural-material-v2';
 
-// -----------------------------------------------------------------------------
-// Deterministic value noise
-// -----------------------------------------------------------------------------
-
-/**
- * Integer hash of a lattice coordinate. Not a cryptographic hash — it only has
- * to decorrelate neighbouring integers and return the same value forever.
- */
-function hash2(x: number, y: number, seed: number): number {
-  let h = (Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(seed, 1274126177)) | 0;
-  h = h ^ (h >>> 13);
-  h = Math.imul(h, 1274126177) | 0;
-  h = h ^ (h >>> 16);
-  return (h >>> 0) / 4294967296;
-}
-
-const smoothstep = (t: number): number => t * t * (3 - 2 * t);
-
-/**
- * Value noise on a lattice that wraps at `period`, so the result tiles.
- * `period` is in lattice cells, and both axes use the same one.
- */
-function valueNoise(u: number, v: number, period: number, seed: number): number {
-  const x = u * period;
-  const y = v * period;
-  const xi = Math.floor(x);
-  const yi = Math.floor(y);
-  const xf = x - xi;
-  const yf = y - yi;
-  // Wrapping the lattice index (not the sample point) is what makes it tile:
-  // the cell to the right of the last one is the first one again.
-  const wrap = (n: number): number => ((n % period) + period) % period;
-  const x0 = wrap(xi);
-  const y0 = wrap(yi);
-  const x1 = wrap(xi + 1);
-  const y1 = wrap(yi + 1);
-  const sx = smoothstep(xf);
-  const sy = smoothstep(yf);
-  const n00 = hash2(x0, y0, seed);
-  const n10 = hash2(x1, y0, seed);
-  const n01 = hash2(x0, y1, seed);
-  const n11 = hash2(x1, y1, seed);
-  const top = n00 + sx * (n10 - n00);
-  const bottom = n01 + sx * (n11 - n01);
-  return top + sy * (bottom - top);
-}
-
-function fbm(u: number, v: number, period: number, octaves: number, seed: number): number {
-  let sum = 0;
-  let amplitude = 1;
-  let total = 0;
-  let p = period;
-  for (let o = 0; o < octaves; o++) {
-    sum += valueNoise(u, v, p, seed + o * 101) * amplitude;
-    total += amplitude;
-    amplitude *= 0.5;
-    // Doubling the period keeps every octave tileable at the base period.
-    p *= 2;
-  }
-  return total > 0 ? sum / total : 0;
-}
-
-// -----------------------------------------------------------------------------
-// Layer evaluation
-// -----------------------------------------------------------------------------
-
-const rgbOf = (color: number): [number, number, number] => [
-  (color >> 16) & 0xff,
-  (color >> 8) & 0xff,
-  color & 0xff,
-];
-
-const lerp = (a: number, b: number, t: number): number => a + (b - a) * t;
-
-/** Rotate normalized coords about the center so angled patterns stay centered. */
-function project(u: number, v: number, angleDeg: number): number {
-  const a = (angleDeg * Math.PI) / 180;
-  return (u - 0.5) * Math.cos(a) + (v - 0.5) * Math.sin(a) + 0.5;
-}
-
-/** Evaluate one layer at a normalized coordinate, returning 0-255 RGB. */
-function evalLayer(
-  layer: CanonicalProceduralLayerV2,
-  u: number,
-  v: number,
-): [number, number, number] {
-  switch (layer.op) {
-    case 'solid':
-      return rgbOf(layer.color);
+export * from './procedural-texture-v3';
+export type ProceduralTextureSpec = LegacyProceduralTextureSpec | ProceduralTextureSpecV3;
 
-    case 'checker': {
-      const cx = Math.floor(u * layer.squares);
-      const cy = Math.floor(v * layer.squares);
-      return rgbOf((cx + cy) % 2 === 0 ? layer.colorA : layer.colorB);
-    }
-
-    case 'stripes': {
-      const t = project(u, v, layer.angleDeg);
-      return rgbOf(Math.floor(t * layer.count) % 2 === 0 ? layer.colorA : layer.colorB);
-    }
-
-    case 'gradient': {
-      const t = Math.min(1, Math.max(0, project(u, v, layer.angleDeg)));
-      const from = rgbOf(layer.from);
-      const to = rgbOf(layer.to);
-      return [lerp(from[0], to[0], t), lerp(from[1], to[1], t), lerp(from[2], to[2], t)];
-    }
-
-    case 'bricks': {
-      const row = Math.floor(v * layer.rows);
-      // Offset alternate rows, wrapping into [0,1) so the pattern still tiles.
-      const shifted = (u + (row % 2 === 0 ? 0 : layer.stagger / layer.cols) + 1) % 1;
-      const inCol = (shifted * layer.cols) % 1;
-      const inRow = (v * layer.rows) % 1;
-      const isMortar =
-        inCol < layer.mortarWidth ||
-        inCol > 1 - layer.mortarWidth ||
-        inRow < layer.mortarWidth ||
-        inRow > 1 - layer.mortarWidth;
-      return rgbOf(isMortar ? layer.mortar : layer.brick);
-    }
-
-    case 'noise': {
-      const n = fbm(u, v, layer.scale, layer.octaves, layer.seed);
-      const a = rgbOf(layer.colorA);
-      const b = rgbOf(layer.colorB);
-      return [lerp(a[0], b[0], n), lerp(a[1], b[1], n), lerp(a[2], b[2], n)];
-    }
-  }
-}
-
-function blendChannel(mode: ProceduralBlend, base: number, top: number): number {
-  const b = base / 255;
-  const t = top / 255;
-  let out: number;
-  switch (mode) {
-    case 'multiply':
-      out = b * t;
-      break;
-    case 'screen':
-      out = 1 - (1 - b) * (1 - t);
-      break;
-    case 'overlay':
-      out = b < 0.5 ? 2 * b * t : 1 - 2 * (1 - b) * (1 - t);
-      break;
-    default:
-      out = t;
-  }
-  return out * 255;
-}
-
-// -----------------------------------------------------------------------------
-// Public API
-// -----------------------------------------------------------------------------
-
-/**
- * Build a tiling texture from a bounded, deterministic layer stack.
- *
- * The result is a plain RGBA `DataTexture`; `renderSceneToGLB` bakes it to PNG
- * and embeds it, so nothing else has to be done to ship it.
- *
- * @example
- * const bark = proceduralTexture({
- *   schemaVersion: 2,
- *   size: 256,
- *   usage: 'albedo',
- *   name: 'Bark',
- *   layers: [
- *     { op: 'solid', color: 0x5a4632 },
- *     { op: 'noise', colorA: 0x3d2f21, colorB: 0x7a6248, scale: 6, octaves: 4, blend: 'overlay' },
- *     { op: 'stripes', colorA: 0x000000, colorB: 0xffffff, count: 24, angleDeg: 90,
- *       blend: 'multiply', opacity: 0.15 },
- *   ],
- * });
- * const trunk = createPart('Trunk', cylinderGeo(0.3, 0.3, 3), pbrMaterial({ albedo: bark }), { parent: root });
- */
-export interface CompiledProceduralTextureV2 {
-  spec: CanonicalProceduralTextureSpecV2;
-  pixels: Uint8Array;
-  canonicalJson: string;
-  recipeHash: `sha256:${string}`;
+/** Dispatch never invokes an input accessor; absent/undefined retains V1 compatibility. */
+export function proceduralTextureSchemaVersion(input: unknown): 1 | 2 | 3 {
+  if (!input || typeof input !== 'object' || Array.isArray(input))
+    throw new ProceduralTextureError(
+      'proceduralTexture requires a plain JSON object.',
+      'PROCEDURAL_TEXTURE_V3_CONTRACT',
+    );
+  const prototype = Object.getPrototypeOf(input);
+  if (prototype !== Object.prototype && prototype !== null)
+    throw new ProceduralTextureError(
+      'proceduralTexture requires a plain JSON object.',
+      'PROCEDURAL_TEXTURE_V3_CONTRACT',
+    );
+  const descriptor = Object.getOwnPropertyDescriptor(input, 'schemaVersion');
+  if (descriptor && (!descriptor.enumerable || !('value' in descriptor)))
+    throw new ProceduralTextureError(
+      'proceduralTexture.schemaVersion must be a JSON data field.',
+      'PROCEDURAL_TEXTURE_V3_CONTRACT',
+    );
+  const version: unknown = descriptor?.value;
+  if (version === undefined || version === 1) return 1;
+  if (version === 2 || version === 3) return version;
+  throw new ProceduralTextureError(
+    'proceduralTexture.schemaVersion must be 1, 2 or 3.',
+    'PROCEDURAL_TEXTURE_V3_CONTRACT',
+  );
 }
 
-/** Validate, canonicalize, and compile one texture without constructing Three.js state. */
-export function compileProceduralTextureSpecV2(input: unknown): CompiledProceduralTextureV2 {
-  const spec = canonicalizeProceduralTextureSpecV2(input);
-  const { size, layers } = spec;
-  const data = new Uint8Array(size * size * 4);
-  for (let y = 0; y < size; y++) {
-    // Sample at texel centers so a pattern with N divisions lands on exact
-    // boundaries instead of drifting half a texel.
-    const v = (y + 0.5) / size;
-    for (let x = 0; x < size; x++) {
-      const u = (x + 0.5) / size;
-      let r = 0;
-      let g = 0;
-      let b = 0;
-      for (const [i, layer] of layers.entries()) {
-        const [lr, lg, lb] = evalLayer(layer, u, v);
-        if (i === 0) {
-          r = lr;
-          g = lg;
-          b = lb;
-          continue;
-        }
-        r = lerp(r, blendChannel(layer.blend, r, lr), layer.opacity);
-        g = lerp(g, blendChannel(layer.blend, g, lg), layer.opacity);
-        b = lerp(b, blendChannel(layer.blend, b, lb), layer.opacity);
-      }
-      const o = (y * size + x) * 4;
-      data[o] = Math.max(0, Math.min(255, Math.round(r)));
-      data[o + 1] = Math.max(0, Math.min(255, Math.round(g)));
-      data[o + 2] = Math.max(0, Math.min(255, Math.round(b)));
-      data[o + 3] = 255;
-    }
-  }
-
-  return {
-    spec,
-    pixels: data,
-    canonicalJson: canonicalProceduralTextureJsonV2(spec),
-    recipeHash: hashProceduralTextureSpecV2(spec),
-  };
-}
+export { compileProceduralTextureSpecV2 } from './procedural-texture-v2-compiler';
+export type { CompiledProceduralTextureV2 } from './procedural-texture-v2-compiler';
 
 export function proceduralTexture(spec: ProceduralTextureSpec): THREE.DataTexture {
+  if (proceduralTextureSchemaVersion(spec) === 3) {
+    const compiled = compileProceduralTextureSpecV3(spec);
+    const { width, height, usage, name } = compiled.spec;
+    const tex = new THREE.DataTexture(
+      compiled.pixels,
+      width,
+      height,
+      THREE.RGBAFormat,
+      THREE.UnsignedByteType,
+    );
+    if (name) tex.name = name;
+    tex.colorSpace =
+      usage === 'albedo' || usage === 'emissive' ? THREE.SRGBColorSpace : THREE.NoColorSpace;
+    tex.wrapS = THREE.RepeatWrapping;
+    tex.wrapT = THREE.RepeatWrapping;
+    tex.minFilter = THREE.LinearMipmapLinearFilter;
+    tex.magFilter = THREE.LinearFilter;
+    tex.generateMipmaps = true;
+    tex.needsUpdate = true;
+    tex.userData['kilnProcedural'] = {
+      ...compiled.spec,
+      canonicalJson: compiled.canonicalJson,
+      recipeHash: compiled.recipeHash,
+      compilerId: compiled.compilerId,
+    };
+    return tex;
+  }
   const compiled = compileProceduralTextureSpecV2(spec);
   const { size, usage, name, layers } = compiled.spec;
 

package/src/project-bundle-node.ts

@@ -12,9 +12,19 @@ import {
   ProjectNotFoundError,
   type ProjectRevision,
 } from './projects';
-import { canonicalMaterialJson, type MaterialRecordV1 } from './material-library';
+import {
+  canonicalMaterialJson,
+  MATERIAL_LIBRARY_LIMITS,
+  type MaterialManifest,
+  type MaterialRecord,
+} from './material-library';
 import { dependencyManifests, resolveSavedAssetMaterials } from './asset-materials-node';
-import { createMaterialLibraryPayload, verifyMaterialRecordV1 } from './material-library-node';
+import {
+  createMaterialLibraryPayload,
+  verifyMaterialRecord,
+  resolveMaterialRecordClosure,
+  validateMaterialManifestIdentityAny,
+} from './material-library-node';
 import {
   PROJECT_BUNDLE_LIMITS,
   decodeProjectBundle,
@@ -26,7 +36,7 @@ import {
 async function assetMaterials(
   workspace: FileWorkspace,
   asset: AssetRecord,
-): Promise<MaterialRecordV1[]> {
+): Promise<MaterialRecord[]> {
   return resolveSavedAssetMaterials(asset, workspace.materials);
 }
 export async function resolveAssetMaterialPayload(workspace: FileWorkspace, asset: AssetRecord) {
@@ -60,27 +70,101 @@ export async function exportWorkspaceProjectBundle(
       ),
     });
   }
-  const materials = new Map<string, MaterialRecordV1>();
+  let materials: MaterialRecord[] = [];
   if (profile === 'editable') {
+    const roots = new Map<string, MaterialManifest>();
+    const assetRoots = new Set<string>();
+    const embedded = new Map<
+      string,
+      { manifest: MaterialManifest; files: Record<string, string> }
+    >();
+    const addRoot = (manifest: MaterialManifest) => {
+      const key = `${manifest.materialId}/${manifest.revisionId}`;
+      const previous = roots.get(key);
+      if (previous && canonicalMaterialJson(previous) !== canonicalMaterialJson(manifest))
+        throw new Error('Conflicting project material identity');
+      roots.set(key, manifest);
+    };
     for (const dependency of project.materialDependencies) {
       if (dependency.sha256 !== dependency.revisionId)
         throw new Error(`Material lock hash mismatch: ${dependency.resourceId}`);
-      let record: MaterialRecordV1;
+      let manifest: MaterialManifest;
       try {
-        record = await workspace.materials.read(dependency.resourceId, dependency.revisionId);
+        manifest = await workspace.materials.readManifest(
+          dependency.resourceId,
+          dependency.revisionId,
+        );
       } catch (error) {
         throw new Error(
           `Locked project material unavailable: ${dependency.resourceId} at ${dependency.revisionId}`,
           { cause: error },
         );
       }
-      materials.set(`${record.manifest.materialId}/${record.manifest.revisionId}`, record);
+      addRoot(manifest);
+    }
+    for (const asset of assets) {
+      for (const manifest of dependencyManifests(asset.record)) {
+        addRoot(manifest);
+        assetRoots.add(`${manifest.materialId}/${manifest.revisionId}`);
+      }
+      for (const wire of asset.record.materialResources?.records ?? []) {
+        const manifest = validateMaterialManifestIdentityAny(wire.manifest);
+        const key = `${manifest.materialId}/${manifest.revisionId}`;
+        const previous = embedded.get(key);
+        if (
+          previous &&
+          (canonicalMaterialJson(previous.manifest) !== canonicalMaterialJson(manifest) ||
+            canonicalMaterialJson(previous.files) !== canonicalMaterialJson(wire.files))
+        )
+          throw new Error('Conflicting embedded material identity');
+        embedded.set(key, { manifest, files: wire.files });
+      }
     }
-    for (const asset of assets)
-      for (const record of await assetMaterials(workspace, asset.record))
-        materials.set(`${record.manifest.materialId}/${record.manifest.revisionId}`, record);
+    const lockedRead = async <T>(
+      id: string,
+      revision: string,
+      read: () => Promise<T>,
+    ): Promise<T> => {
+      try {
+        return await read();
+      } catch (error) {
+        throw new Error(
+          `Locked ${assetRoots.has(`${id}/${revision}`) ? 'asset' : 'project'} material unavailable: ${id} at ${revision}`,
+          { cause: error },
+        );
+      }
+    };
+    materials = await resolveMaterialRecordClosure(
+      [...roots.values()],
+      {
+        readManifest: async (id, revision) =>
+          embedded.get(`${id}/${revision}`)?.manifest ??
+          lockedRead(id, revision, () => workspace.materials.readManifest(id, revision)),
+        read: async (id, revision) => {
+          const wire = embedded.get(`${id}/${revision}`);
+          if (!wire)
+            return lockedRead(id, revision, () =>
+              workspace.materials.readRecordFiles(id, revision),
+            );
+          return {
+            manifest: wire.manifest,
+            files: Object.fromEntries(
+              Object.entries(wire.files).map(([name, value]) => [
+                name,
+                new Uint8Array(Buffer.from(value, 'base64')),
+              ]),
+            ),
+          } as MaterialRecord;
+        },
+      },
+      {
+        maxRecords: 1024,
+        maxBytes: PROJECT_BUNDLE_LIMITS.maxBytes,
+        maxPixels: 1024 * MATERIAL_LIBRARY_LIMITS.maxRecordPixels,
+      },
+    );
   }
-  return encodeProjectBundle({ project, assets, materials: [...materials.values()] }, profile);
+  return encodeProjectBundle({ project, assets, materials }, profile);
 }
 
 async function retainArchive(workspace: FileWorkspace, bytes: Uint8Array, digest: string) {
@@ -153,7 +237,8 @@ export async function importWorkspaceProjectBundle(
       record,
     ]),
   );
-  for (const record of decoded.materials) await verifyMaterialRecordV1(record);
+  for (const record of decoded.materials)
+    await verifyMaterialRecord(record, { materials: decoded.materials });
   for (const asset of decoded.assets) {
     await verifyAssetRecord(asset.record);
     for (const manifest of dependencyManifests(asset.record)) {
@@ -211,8 +296,15 @@ export async function importWorkspaceProjectBundle(
   // Nothing above performs writes. Verified immutable resources can safely survive a
   // later disk failure or project-ID conflict; imports never overwrite other revisions.
   await retainArchive(workspace, snapshot, digest);
-  for (let i = 0; i < decoded.materials.length; i += 100)
-    await workspace.materials.import(decoded.materials.slice(i, i + 100));
+  const newMaterialContext = decoded.materials.some(
+    (record) => record.manifest.schemaVersion === 2,
+  );
+  for (let i = 0; i < decoded.materials.length; i += 100) {
+    const batch = decoded.materials.slice(i, i + 100);
+    if (newMaterialContext)
+      await workspace.materials.import(batch, { materials: decoded.materials });
+    else await workspace.materials.import(batch);
+  }
   const records = [...destinationRecords.values()];
   for (let i = 0; i < records.length; i += 100)
     await library.import(options.collectionId, records.slice(i, i + 100));

package/src/project-bundle.ts

@@ -14,8 +14,10 @@ import { MAX_PROJECT_REVISIONS, projectRevisionSchema, type ProjectRevision } fr
 import {
   canonicalMaterialJson,
   materialManifestSchema,
-  validateMaterialRecordShape,
-  type MaterialRecordV1,
+  materialManifestAnySchema,
+  materialRecordDependencyPins,
+  validateMaterialRecordShapeAny,
+  type MaterialRecord,
 } from './material-library';
 
 export const PROJECT_BUNDLE_LIMITS = Object.freeze({
@@ -69,7 +71,16 @@ export const projectBundleManifestSchema = z
     ),
   })
   .strict();
-export type ProjectBundleManifest = z.infer<typeof projectBundleManifestSchema>;
+export const projectBundleManifestV2Schema = projectBundleManifestSchema.extend({
+  version: z.literal('kiln.project-bundle.v2'),
+});
+export const projectBundleManifestAnySchema = z.union([
+  projectBundleManifestSchema,
+  projectBundleManifestV2Schema,
+]);
+export type ProjectBundleManifestV1 = z.infer<typeof projectBundleManifestSchema>;
+export type ProjectBundleManifestV2 = z.infer<typeof projectBundleManifestV2Schema>;
+export type ProjectBundleManifest = ProjectBundleManifestV1 | ProjectBundleManifestV2;
 export interface ProjectBundleAsset {
   inventoryId: string;
   collectionId: string;
@@ -77,7 +88,7 @@ export interface ProjectBundleAsset {
 }
 export interface ProjectBundleInput {
   project: ProjectRevision;
-  materials: MaterialRecordV1[];
+  materials: MaterialRecord[];
   assets: ProjectBundleAsset[];
 }
 export interface DecodedProjectBundle extends ProjectBundleInput {
@@ -117,8 +128,8 @@ async function verifyAsset(record: AssetRecord) {
     if ((await projectBundleHash(file)) !== record.manifest.files[name]!.sha256)
       throw new Error('Asset file hash mismatch');
 }
-async function verifyMaterial(record: MaterialRecordV1) {
-  const manifest = validateMaterialRecordShape(record);
+async function verifyMaterial(record: MaterialRecord) {
+  const manifest = validateMaterialRecordShapeAny(record);
   const { revisionId, ...payload } = manifest;
   if ((await projectBundleHash(encoder.encode(canonicalMaterialJson(payload)))) !== revisionId)
     throw new Error('Material revision hash mismatch');
@@ -144,10 +155,9 @@ function assertAssetSelection(project: ProjectRevision, entries: ProjectBundleMa
       throw new Error('Bundle inventory asset binding mismatch');
   }
 }
-function assertMaterialClosure(project: ProjectRevision, records: MaterialRecordV1[]) {
-  const identities = records.map(
-    (record) => `${record.manifest.materialId}/${record.manifest.revisionId}`,
-  );
+function assertMaterialClosure(project: ProjectRevision, records: MaterialRecord[]) {
+  const manifests = records.map((record) => validateMaterialRecordShapeAny(record));
+  const identities = manifests.map((manifest) => `${manifest.materialId}/${manifest.revisionId}`);
   if (new Set(identities).size !== identities.length)
     throw new Error('Duplicate material revision');
   for (const dependency of project.materialDependencies)
@@ -156,6 +166,33 @@ function assertMaterialClosure(project: ProjectRevision, records: MaterialRecord
       !identities.includes(`${dependency.resourceId}/${dependency.revisionId}`)
     )
       throw new Error(`Missing locked material: ${dependency.resourceId}`);
+  const byKey = new Map(
+    manifests.map((manifest) => [`${manifest.materialId}/${manifest.revisionId}`, manifest]),
+  );
+  const visited = new Set<string>();
+  for (const key of identities) {
+    const active = new Set<string>();
+    const stack: Array<{ key: string; exit: boolean }> = [{ key, exit: false }];
+    while (stack.length) {
+      const frame = stack.pop()!;
+      if (frame.exit) {
+        active.delete(frame.key);
+        visited.add(frame.key);
+        continue;
+      }
+      if (active.has(frame.key)) throw new Error('Cyclic project material closure');
+      if (visited.has(frame.key)) continue;
+      const manifest = byKey.get(frame.key);
+      if (!manifest) throw new Error('Missing transitive project material');
+      active.add(frame.key);
+      stack.push({ key: frame.key, exit: true });
+      for (const pin of materialRecordDependencyPins(manifest)) {
+        if (pin.sha256 !== pin.revisionId)
+          throw new Error('Transitive material lock hash mismatch');
+        stack.push({ key: `${pin.resourceId}/${pin.revisionId}`, exit: false });
+      }
+    }
+  }
 }
 
 /** Editable includes normalized rebuild resources; runtime intentionally excludes source/recipes. */
@@ -228,8 +265,12 @@ export async function encodeProjectBundle(
       for (const [name, bytes] of Object.entries(record.files)) add(prefix + name, bytes);
     }
   }
-  const manifest = projectBundleManifestSchema.parse({
-    version: 'kiln.project-bundle.v1',
+  const version =
+    profile === 'editable' && input.materials.some((record) => record.manifest.schemaVersion === 2)
+      ? 'kiln.project-bundle.v2'
+      : 'kiln.project-bundle.v1';
+  const manifest = projectBundleManifestAnySchema.parse({
+    version,
     profile,
     editable: profile === 'editable',
     resourceClosure:
@@ -294,7 +335,7 @@ export async function decodeProjectBundle(bytes: Uint8Array): Promise<DecodedPro
     }
     return value;
   };
-  const manifest = projectBundleManifestSchema.parse(
+  const manifest = projectBundleManifestAnySchema.parse(
     json('bundle.json', PROJECT_BUNDLE_LIMITS.maxManifestBytes),
   );
   if (
@@ -314,7 +355,7 @@ export async function decodeProjectBundle(bytes: Uint8Array): Promise<DecodedPro
   assertAssetSelection(project, manifest.assets);
   const used = new Set(['bundle.json', 'project.json']);
   const assets: ProjectBundleAsset[] = [];
-  const materials: MaterialRecordV1[] = [];
+  const materials: MaterialRecord[] = [];
   const runtimeAssets: DecodedProjectBundle['runtimeAssets'] = [];
   for (const identity of manifest.assets) {
     const prefix = assetPrefix(identity);
@@ -367,16 +408,18 @@ export async function decodeProjectBundle(bytes: Uint8Array): Promise<DecodedPro
     throw new Error('Runtime profile contains editable material records');
   for (const identity of manifest.materials) {
     const prefix = materialPrefix(identity);
-    const materialManifest = materialManifestSchema.parse(
-      json(`${prefix}manifest.json`, 256 * 1024),
-    );
+    const materialManifest = (
+      manifest.version === 'kiln.project-bundle.v1'
+        ? materialManifestSchema
+        : materialManifestAnySchema
+    ).parse(json(`${prefix}manifest.json`, 256 * 1024));
     used.add(`${prefix}manifest.json`);
     if (
       materialManifest.materialId !== identity.materialId ||
       materialManifest.revisionId !== identity.revisionId
     )
       throw new Error('Bundle material identity mismatch');
-    const record: MaterialRecordV1 = { manifest: materialManifest, files: {} };
+    const record = { manifest: materialManifest, files: {} } as MaterialRecord;
     for (const map of materialManifest.maps) {
       const bytes = files[prefix + map.file];
       if (!bytes) throw new Error('Missing material map');