@aura3d/product-studio 1.4.0 → 1.4.2

package/README.md

@@ -0,0 +1,27 @@
+# @aura3d/product-studio
+
+`@aura3d/product-studio` owns product asset loading, camera framing,
+diagnostics, export, floor, lighting, material modes, render scenes, and
+showcase layouts for Aura3D product workflows.
+
+## Public API
+
+- `loadProductAsset`: product asset loading boundary.
+- `createProductCameraFrame`, `validateProductCameraFrame`: product camera
+  framing helpers.
+- `createProductDiagnostics`: product scene diagnostics.
+- `exportProductRender`, `exportProductSceneManifest`: product export helpers.
+- `createProductFloor`, `createProductLightingPreset`: floor and lighting
+  presets for product scenes.
+- `createProductMaterialMode`, `applyProductMaterialMode`: material mode
+  selection and application.
+- `createProductRenderScene`, `updateProductRenderScene`: product render scene
+  construction and updates.
+- `createProductShowcaseLayout`: product showcase layout helpers.
+- `createProductStudio`: product studio workflow assembly.
+
+## Package Boundary
+
+This package is the product workflow layer. Public examples should still use
+typed GLB/glTF assets from the CLI pipeline and only claim product-rendering
+capabilities that have route-health, screenshot, and browser evidence.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/product-studio",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "type": "module",
   "exports": {
     ".": {
@@ -11,9 +11,41 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@aura3d/assets": "1.4.0",
-    "@aura3d/rendering": "1.4.0",
-    "@aura3d/scene": "1.4.0"
+    "@aura3d/assets": "1.4.2",
+    "@aura3d/rendering": "1.4.2",
+    "@aura3d/scene": "1.4.2"
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "description": "Product asset loading, camera framing, diagnostics, export, floor, lighting, material modes, render scenes, and showcase layouts for Aura3D.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "product-studio",
+    "product-viewer",
+    "product-configurator",
+    "3d-commerce",
+    "product-rendering",
+    "materials",
+    "lighting"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/product-studio"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/ProductAsset.ts

@@ -1,8 +0,0 @@
-export type {
-  ProductAsset,
-  ProductAssetId,
-  ProductAssetLoadOptions,
-  ProductManifest,
-  ProductMaterialDescriptor,
-  ProductPartDescriptor
-} from "./ProductTypes";

package/src/ProductAssetLoader.ts

@@ -1,83 +0,0 @@
-import { createGLTFRenderResources, GLTFLoader, LoadContext, type DecodedGLTFImage } from "@aura3d/assets";
-import type { ProductAsset, ProductAssetLoadOptions, ProductManifest } from "./ProductTypes";
-
-export async function loadProductAsset(options: ProductAssetLoadOptions): Promise<ProductAsset> {
-  const loader = new GLTFLoader();
-  const context = new LoadContext();
-  const gltf = await loader.load({ url: options.url }, context);
-  const manifest = await loadManifest(options, gltf);
-  const resources = await createGLTFRenderResources(gltf, nativeImageDecodeAvailable() ? {} : { imageDecoder: fallbackImageDecoder });
-  const parts = manifest.parts.length > 0
-    ? manifest.parts
-    : gltf.meshes.map((mesh) => ({ name: mesh.name, material: mesh.material, shape: "mesh" }));
-  const materials = manifest.materials.length > 0
-    ? manifest.materials
-    : gltf.materials.map((material) => ({
-      name: material.name,
-      metallic: material.metallicFactor,
-      roughness: material.roughnessFactor,
-      alphaMode: material.alphaMode
-    }));
-
-  return {
-    id: manifest.id,
-    title: manifest.title,
-    category: manifest.category,
-    url: options.url,
-    manifest,
-    gltf,
-    resources,
-    parts,
-    materials
-  };
-}
-
-function nativeImageDecodeAvailable(): boolean {
-  return typeof createImageBitmap === "function" || typeof globalThis.Image === "function";
-}
-
-function fallbackImageDecoder(): DecodedGLTFImage {
-  return {
-    width: 1,
-    height: 1,
-    colorSpace: "srgb",
-    data: new Uint8Array([220, 220, 220, 255])
-  };
-}
-
-async function loadManifest(options: ProductAssetLoadOptions, gltf: Awaited<ReturnType<GLTFLoader["load"]>>): Promise<ProductManifest> {
-  const manifestUrl = options.manifestUrl ?? options.url.replace(/\/[^/]+\.gltf(?:\?.*)?$/i, "/manifest.json");
-  if (typeof fetch === "function") {
-    const response = await fetch(manifestUrl);
-    if (response.ok) {
-      const manifest = await response.json() as ProductManifest;
-      return normalizeManifest(manifest, options);
-    }
-  }
-  return normalizeManifest({
-    schema: "a3d-product-manifest/fallback",
-    id: options.id ?? "product",
-    title: options.title ?? gltf.scenes[gltf.defaultScene]?.name ?? "Product",
-    category: options.category ?? "product",
-    gltf: options.url,
-    parts: gltf.meshes.map((mesh) => ({ name: mesh.name, material: mesh.material, shape: "mesh" })),
-    materials: gltf.materials.map((material) => ({
-      name: material.name,
-      metallic: material.metallicFactor,
-      roughness: material.roughnessFactor,
-      alphaMode: material.alphaMode
-    }))
-  }, options);
-}
-
-function normalizeManifest(manifest: ProductManifest, options: ProductAssetLoadOptions): ProductManifest {
-  return {
-    ...manifest,
-    id: options.id ?? manifest.id,
-    title: options.title ?? manifest.title,
-    category: options.category ?? manifest.category,
-    gltf: manifest.gltf ?? options.url,
-    parts: manifest.parts ?? [],
-    materials: manifest.materials ?? []
-  };
-}

package/src/ProductCamera.ts

@@ -1,48 +0,0 @@
-import { computePerspectiveCameraFrame } from "@aura3d/rendering";
-import type { ProductAsset, ProductCameraFrame, ProductCameraOptions, ProductCameraPreset } from "./ProductTypes";
-
-const CAMERA_PRESETS: Record<ProductCameraPreset, { readonly yaw: number; readonly pitch: number; readonly padding: number }> = {
-  "front-three-quarter": { yaw: -0.42, pitch: -0.16, padding: 0.22 },
-  "side-profile": { yaw: Math.PI / 2, pitch: -0.08, padding: 0.28 },
-  "top-detail": { yaw: -0.22, pitch: -0.92, padding: 0.2 },
-  "macro-detail": { yaw: -0.5, pitch: -0.12, padding: 0.02 }
-};
-
-export function createProductCameraFrame(asset: ProductAsset, options: ProductCameraOptions = {}): ProductCameraFrame {
-  const preset = options.preset ?? "front-three-quarter";
-  const viewport = options.viewport ?? { width: 1280, height: 900 };
-  const config = CAMERA_PRESETS[preset];
-  const frame = computePerspectiveCameraFrame(asset.resources.bounds, viewport, {
-    paddingRatio: options.paddingRatio ?? config.padding,
-    yawRadians: config.yaw,
-    pitchRadians: config.pitch,
-    nearPadding: preset === "macro-detail" ? 0.04 : 0.16,
-    farPadding: 2.4,
-    minDistance: preset === "macro-detail" ? 0.35 : 1
-  });
-  const camera = {
-    projectionMatrix: frame.projectionMatrix,
-    viewMatrix: frame.viewMatrix,
-    viewProjectionMatrix: frame.viewProjectionMatrix,
-    cameraPosition: frame.cameraPosition
-  };
-  validateProductCameraFrame({ preset, frame, camera });
-  return { preset, frame, camera };
-}
-
-export function validateProductCameraFrame(frame: ProductCameraFrame): void {
-  const numbers = [
-    ...frame.frame.center,
-    ...frame.frame.cameraPosition,
-    frame.frame.near,
-    frame.frame.far,
-    frame.frame.aspect,
-    ...Array.from(frame.frame.viewProjectionMatrix)
-  ];
-  if (numbers.some((value) => !Number.isFinite(value))) {
-    throw new RangeError(`Product camera frame ${frame.preset} contains a non-finite value.`);
-  }
-  if (frame.frame.far <= frame.frame.near) {
-    throw new RangeError(`Product camera frame ${frame.preset} far plane must exceed near plane.`);
-  }
-}

package/src/ProductDiagnostics.ts

@@ -1,19 +0,0 @@
-import type { RenderDeviceDiagnostics } from "@aura3d/rendering";
-import type { ProductAsset, ProductDiagnostics } from "./ProductTypes";
-
-export function createProductDiagnostics(asset: ProductAsset, renderDiagnostics?: RenderDeviceDiagnostics): ProductDiagnostics {
-  const warnings: string[] = [];
-  if (asset.parts.length < 8) warnings.push(`Product asset ${asset.id} has too few named parts for Product Studio.`);
-  if (asset.materials.length < 3) warnings.push(`Product asset ${asset.id} has too few named materials for Product Studio.`);
-  if (asset.gltf.images.length === 0 || asset.gltf.textures.length === 0) warnings.push(`Product asset ${asset.id} is missing texture-backed materials.`);
-  if (asset.gltf.meshes.some((mesh) => !mesh.name)) warnings.push(`Product asset ${asset.id} contains unnamed meshes.`);
-  return {
-    assetId: asset.id,
-    partCount: asset.parts.length,
-    materialCount: asset.materials.length,
-    textureCount: asset.gltf.textures.length,
-    meshCount: asset.gltf.meshes.length,
-    warnings,
-    ...(renderDiagnostics ? { renderDiagnostics } : {})
-  };
-}

package/src/ProductExport.ts

@@ -1,43 +0,0 @@
-import type { ProductExportResult, ProductRenderScene, ProductSceneManifest } from "./ProductTypes";
-
-export async function exportProductRender(canvas: HTMLCanvasElement | OffscreenCanvas, scene: ProductRenderScene): Promise<ProductExportResult> {
-  const dataUrl = await canvasToDataUrl(canvas);
-  return {
-    mimeType: "image/png",
-    dataUrl,
-    byteLength: dataUrl.length,
-    manifest: exportProductSceneManifest(scene)
-  };
-}
-
-export function exportProductSceneManifest(scene: ProductRenderScene): ProductSceneManifest {
-  return {
-    schema: "a3d-product-studio-scene",
-    assetId: scene.asset.id,
-    title: scene.asset.title,
-    partCount: scene.asset.parts.length,
-    materialCount: scene.asset.materials.length,
-    materialMode: scene.materialMode.id,
-    lightingPreset: scene.lighting.preset,
-    cameraPreset: scene.cameraFrame.preset,
-    generatedAt: new Date().toISOString()
-  };
-}
-
-async function canvasToDataUrl(canvas: HTMLCanvasElement | OffscreenCanvas): Promise<string> {
-  if ("toDataURL" in canvas && typeof canvas.toDataURL === "function") {
-    return canvas.toDataURL("image/png");
-  }
-  if ("convertToBlob" in canvas && typeof canvas.convertToBlob === "function") {
-    const blob = await canvas.convertToBlob({ type: "image/png" });
-    const buffer = await blob.arrayBuffer();
-    return `data:image/png;base64,${base64(buffer)}`;
-  }
-  throw new Error("Product render export requires HTMLCanvasElement.toDataURL or OffscreenCanvas.convertToBlob.");
-}
-
-function base64(buffer: ArrayBuffer): string {
-  let binary = "";
-  for (const byte of new Uint8Array(buffer)) binary += String.fromCharCode(byte);
-  return btoa(binary);
-}

package/src/ProductFloor.ts

@@ -1,17 +0,0 @@
-import { composeMat4 } from "@aura3d/scene";
-import { Geometry, PBRMaterial } from "@aura3d/rendering";
-import type { RenderItem } from "@aura3d/rendering";
-import type { ProductAsset } from "./ProductTypes";
-
-export function createProductFloor(asset: ProductAsset): RenderItem {
-  const bounds = asset.resources.bounds;
-  const width = Math.max(bounds.max[0] - bounds.min[0], bounds.max[2] - bounds.min[2], 1) * 3.2;
-  const y = bounds.min[1] - 0.04;
-  return {
-    label: "product-studio-floor",
-    geometry: Geometry.texturedCube(1),
-    material: new PBRMaterial({ name: "product-studio-floor-material", baseColor: [0.72, 0.73, 0.72, 1], metallic: 0, roughness: 0.62 }),
-    includeInAutoFrame: false,
-    modelMatrix: composeMat4([0, y, 0], [0, 0, 0, 1], [width, 0.035, width])
-  };
-}

package/src/ProductLighting.ts

@@ -1,52 +0,0 @@
-import { DirectionalLight } from "@aura3d/scene";
-import { createLightingDefault } from "@aura3d/rendering";
-import type { CollectedLight } from "@aura3d/rendering";
-import type { ProductLightingConfig, ProductLightingPreset } from "./ProductTypes";
-
-export function createProductLightingPreset(preset: ProductLightingPreset = "catalog-softbox"): ProductLightingConfig {
-  const base = createLightingDefault(preset === "inspection-bay" ? "interiorGallery" : preset === "hero-contrast" ? "gameNight" : "studioProduct");
-  const key = makeDirectionalLight("product-key-light", [1, 0.92, 0.82], preset === "hero-contrast" ? 3.6 : 2.8, [0.42, -0.72, -0.55], true);
-  const rim = makeDirectionalLight("product-rim-light", [0.58, 0.68, 1], preset === "inspection-bay" ? 0.8 : 1.15, [-0.56, -0.28, 0.78], false);
-  return {
-    preset,
-    environmentLighting: base.environmentLighting,
-    postprocess: base.postprocess,
-    shadow: {
-      ...base.shadow,
-      light: key.source,
-      strength: preset === "inspection-bay" ? 0.32 : preset === "hero-contrast" ? 0.5 : 0.38
-    },
-    lights: [key, rim]
-  };
-}
-
-function makeDirectionalLight(
-  name: string,
-  color: readonly [number, number, number],
-  intensity: number,
-  direction: readonly [number, number, number],
-  castsShadow: boolean
-): CollectedLight {
-  const source = new DirectionalLight(name);
-  source.color = [...color] as [number, number, number];
-  source.intensity = intensity;
-  source.castsShadow = castsShadow;
-  return {
-    kind: "directional",
-    color,
-    intensity,
-    position: [0, 0, 0],
-    direction: normalize(direction),
-    range: 0,
-    spotAngle: 0,
-    penumbra: 0,
-    castsShadow,
-    layerMask: 0xffffffff,
-    source
-  };
-}
-
-function normalize(value: readonly [number, number, number]): readonly [number, number, number] {
-  const length = Math.hypot(value[0], value[1], value[2]);
-  return length === 0 ? [0, -1, -1] : [value[0] / length, value[1] / length, value[2] / length];
-}

package/src/ProductMaterials.ts

@@ -1,45 +0,0 @@
-import { PBRMaterial } from "@aura3d/rendering";
-import type { Material } from "@aura3d/rendering";
-import type { ProductAsset, ProductMaterialMode, ProductMaterialModeId } from "./ProductTypes";
-
-export function createProductMaterialMode(id: ProductMaterialModeId = "asset"): ProductMaterialMode {
-  switch (id) {
-    case "asset":
-      return { id, label: "Asset", description: "Use product-authored glTF materials." };
-    case "clay":
-      return { id, label: "Clay", description: "Neutral clay material for shape review." };
-    case "matte":
-      return { id, label: "Matte", description: "Low-glare product material pass." };
-    case "metal-check":
-      return { id, label: "Metal", description: "High-metallic inspection material pass." };
-    case "contrast":
-      return { id, label: "Contrast", description: "High contrast material separation pass." };
-  }
-}
-
-export function applyProductMaterialMode(asset: ProductAsset, mode: ProductMaterialMode): ReadonlyMap<string, Material> {
-  if (mode.id === "asset") {
-    return asset.resources.materialLibrary;
-  }
-  const output = new Map<string, Material>();
-  let index = 0;
-  for (const key of asset.resources.materialLibrary.keys()) {
-    output.set(key, materialForMode(mode.id, index));
-    index += 1;
-  }
-  return output;
-}
-
-function materialForMode(mode: ProductMaterialModeId, index: number): PBRMaterial {
-  if (mode === "metal-check") {
-    return new PBRMaterial({ name: `product-metal-check-${index}`, baseColor: [0.72, 0.72, 0.68, 1], metallic: 1, roughness: 0.18 });
-  }
-  if (mode === "contrast") {
-    const palette = [[0.9, 0.16, 0.12, 1], [0.1, 0.42, 0.86, 1], [0.96, 0.76, 0.18, 1], [0.16, 0.72, 0.38, 1]] as const;
-    return new PBRMaterial({ name: `product-contrast-${index}`, baseColor: palette[index % palette.length], metallic: 0.15, roughness: 0.42 });
-  }
-  if (mode === "matte") {
-    return new PBRMaterial({ name: `product-matte-${index}`, baseColor: [0.56, 0.6, 0.58, 1], metallic: 0, roughness: 0.86 });
-  }
-  return new PBRMaterial({ name: `product-clay-${index}`, baseColor: [0.74, 0.7, 0.64, 1], metallic: 0, roughness: 0.74 });
-}

package/src/ProductRenderScene.ts

@@ -1,49 +0,0 @@
-import { createGLTFRenderSource } from "@aura3d/assets";
-import { createProductCameraFrame } from "./ProductCamera";
-import { createProductFloor } from "./ProductFloor";
-import { createProductLightingPreset } from "./ProductLighting";
-import { applyProductMaterialMode, createProductMaterialMode } from "./ProductMaterials";
-import type { ProductAsset, ProductRenderScene, ProductRenderSceneOptions } from "./ProductTypes";
-
-export function createProductRenderScene(asset: ProductAsset, options: ProductRenderSceneOptions = {}): ProductRenderScene {
-  const lighting = options.lighting ?? createProductLightingPreset();
-  const camera = options.camera ?? createProductCameraFrame(asset);
-  const materialMode = options.materialMode ?? createProductMaterialMode("asset");
-  const renderItems = options.floor === false ? [] : [createProductFloor(asset)];
-  const baseSource = createGLTFRenderSource({
-    scene: asset.resources.scene,
-    geometryLibrary: asset.resources.geometryLibrary,
-    materialLibrary: applyProductMaterialMode(asset, materialMode),
-    morphTargetLibrary: asset.resources.morphTargetLibrary,
-    bounds: asset.resources.bounds
-  }, {
-    qualityPreset: "hdr-studio-preview",
-    environmentLighting: lighting.environmentLighting,
-    postprocess: lighting.postprocess,
-    shadow: lighting.shadow,
-    renderItems,
-    cameraPolicy: "require",
-    cameraPosition: camera.frame.cameraPosition,
-    frustumCulling: true
-  });
-  const source = { ...baseSource, collectedLights: lighting.lights };
-
-  return {
-    asset,
-    source,
-    camera: camera.camera,
-    cameraFrame: camera,
-    lighting,
-    materialMode,
-    renderItems
-  };
-}
-
-export function updateProductRenderScene(scene: ProductRenderScene, options: ProductRenderSceneOptions = {}): ProductRenderScene {
-  return createProductRenderScene(scene.asset, {
-    lighting: options.lighting ?? scene.lighting,
-    camera: options.camera ?? scene.cameraFrame,
-    materialMode: options.materialMode ?? scene.materialMode,
-    floor: options.floor
-  });
-}

package/src/ProductShowcaseLayout.ts

@@ -1,90 +0,0 @@
-export type ProductShowcaseSlot = "hero" | "left-detail" | "left-transparent" | "right-variant";
-
-export interface ProductShowcaseSlotInput {
-  readonly assetId: string;
-  readonly slot: ProductShowcaseSlot;
-  readonly materialVariantControl?: string;
-  readonly defaultMaterialVariant?: string;
-}
-
-export interface ProductShowcaseLayoutItem {
-  readonly assetId: string;
-  readonly slot: ProductShowcaseSlot;
-  readonly position: readonly [number, number, number];
-  readonly scale: readonly [number, number, number];
-  readonly targetHeight: number;
-  readonly yawRadians: number;
-  readonly turntableSpeedRadiansPerSecond: number;
-  readonly materialVariantControl?: string;
-  readonly defaultMaterialVariant?: string;
-}
-
-export interface ProductShowcaseFrame {
-  readonly boundsMin: readonly [number, number, number];
-  readonly boundsMax: readonly [number, number, number];
-  readonly heroPaddingRatio: number;
-}
-
-export interface ProductShowcaseLayout {
-  readonly schema: "a3d-product-showcase-layout";
-  readonly mode: "hero-product-with-secondary-detail";
-  readonly items: readonly ProductShowcaseLayoutItem[];
-  readonly frame: ProductShowcaseFrame;
-  readonly limitations: readonly string[];
-}
-
-const COMPACT_SLOT_LAYOUT: Record<ProductShowcaseSlot, Omit<ProductShowcaseLayoutItem, "assetId" | "slot" | "materialVariantControl" | "defaultMaterialVariant">> = {
-  hero: {
-    position: [-0.28, -0.88, 0.0],
-    scale: [1, 1, 1],
-    targetHeight: 0.92,
-    yawRadians: -0.38,
-    turntableSpeedRadiansPerSecond: 0.001
-  },
-  "left-detail": {
-    position: [-2.28, -0.86, -0.72],
-    scale: [1, 1, 1],
-    targetHeight: 0.24,
-    yawRadians: 0.34,
-    turntableSpeedRadiansPerSecond: 0.1
-  },
-  "left-transparent": {
-    position: [-2.36, -0.87, 0.68],
-    scale: [1, 1, 1],
-    targetHeight: 0.11,
-    yawRadians: 0.58,
-    turntableSpeedRadiansPerSecond: 0.06
-  },
-  "right-variant": {
-    position: [2.34, -0.86, 0.58],
-    scale: [1, 1, 1],
-    targetHeight: 0.24,
-    yawRadians: -0.82,
-    turntableSpeedRadiansPerSecond: 0.08
-  }
-};
-
-const COMPACT_FRAME: ProductShowcaseFrame = {
-  boundsMin: [-1.3, -1.0, -0.78],
-  boundsMax: [1.3, 0.5, 0.86],
-  heroPaddingRatio: 0.02
-};
-
-export function createProductShowcaseLayout(slots: readonly ProductShowcaseSlotInput[]): ProductShowcaseLayout {
-  return {
-    schema: "a3d-product-showcase-layout",
-    mode: "hero-product-with-secondary-detail",
-    items: slots.map((slot) => ({
-      assetId: slot.assetId,
-      slot: slot.slot,
-      ...COMPACT_SLOT_LAYOUT[slot.slot],
-      ...(slot.materialVariantControl ? { materialVariantControl: slot.materialVariantControl } : {}),
-      ...(slot.defaultMaterialVariant ? { defaultMaterialVariant: slot.defaultMaterialVariant } : {})
-    })),
-    frame: COMPACT_FRAME,
-    limitations: [
-      "This layout helper owns deterministic hero-first product staging and camera bounds; secondary products remain loaded but are kept outside the default hero frame so they cannot read as debris attached to the car.",
-      "The layout does not infer a semantic part graph from imported GLBs; imported mesh triangle picking, authored exploded timelines, and physical contact shadows remain separate engine/runtime capabilities."
-    ]
-  };
-}

package/src/ProductStudio.ts

@@ -1,72 +0,0 @@
-import { Renderer } from "@aura3d/rendering";
-import { createProductCameraFrame } from "./ProductCamera";
-import { exportProductRender, exportProductSceneManifest } from "./ProductExport";
-import { createProductLightingPreset } from "./ProductLighting";
-import { createProductMaterialMode } from "./ProductMaterials";
-import type {
-  ProductAsset,
-  ProductCameraFrame,
-  ProductCameraPreset,
-  ProductExportResult,
-  ProductLightingConfig,
-  ProductLightingPreset,
-  ProductMaterialMode,
-  ProductMaterialModeId,
-  ProductRenderScene,
-  ProductSceneManifest,
-  ProductStudio,
-  ProductStudioOptions
-} from "./ProductTypes";
-
-export async function createProductStudio(options: ProductStudioOptions = {}): Promise<ProductStudio> {
-  const renderer = await Renderer.create({
-    clearColor: [0.03, 0.035, 0.038, 1],
-    width: options.width ?? 1280,
-    height: options.height ?? 900,
-    ...options
-  });
-  return new ProductStudioRuntime(renderer, options.canvas);
-}
-
-class ProductStudioRuntime implements ProductStudio {
-  constructor(
-    public readonly renderer: Renderer,
-    private readonly canvas?: HTMLCanvasElement | OffscreenCanvas
-  ) {}
-
-  render(scene: ProductRenderScene) {
-    return this.renderer.render(scene.source, scene.camera);
-  }
-
-  resize(width: number, height: number): void {
-    this.renderer.resize(width, height);
-  }
-
-  setLighting(preset: ProductLightingPreset): ProductLightingConfig {
-    return createProductLightingPreset(preset);
-  }
-
-  setCamera(asset: ProductAsset, preset: ProductCameraPreset, viewport = { width: 1280, height: 900 }): ProductCameraFrame {
-    return createProductCameraFrame(asset, { preset, viewport });
-  }
-
-  setMaterialMode(mode: ProductMaterialModeId): ProductMaterialMode {
-    return createProductMaterialMode(mode);
-  }
-
-  async exportPng(scene: ProductRenderScene): Promise<ProductExportResult> {
-    if (!this.canvas) {
-      throw new Error("ProductStudio exportPng requires a canvas-backed studio.");
-    }
-    this.render(scene);
-    return exportProductRender(this.canvas, scene);
-  }
-
-  exportSceneManifest(scene: ProductRenderScene): ProductSceneManifest {
-    return exportProductSceneManifest(scene);
-  }
-
-  dispose(): void {
-    this.renderer.dispose();
-  }
-}

package/src/ProductTypes.ts

@@ -1,158 +0,0 @@
-import type { GLTFAsset, GLTFRenderResources } from "@aura3d/assets";
-import type {
-  CameraLike,
-  CollectedLight,
-  EnvironmentLightingOptions,
-  PerspectiveCameraFrame,
-  RenderDeviceDiagnostics,
-  RenderItem,
-  Renderer,
-  RendererOptions,
-  RendererPostProcessOptions,
-  RendererShadowOptions,
-  RenderSource
-} from "@aura3d/rendering";
-
-export type ProductAssetId = "camera-kit" | "speaker" | "watch" | (string & {});
-export type ProductLightingPreset = "catalog-softbox" | "inspection-bay" | "hero-contrast";
-export type ProductCameraPreset = "front-three-quarter" | "side-profile" | "top-detail" | "macro-detail";
-export type ProductMaterialModeId = "asset" | "clay" | "matte" | "metal-check" | "contrast";
-
-export interface ProductPartDescriptor {
-  readonly name: string;
-  readonly material: string;
-  readonly shape?: string;
-}
-
-export interface ProductMaterialDescriptor {
-  readonly name: string;
-  readonly metallic: number;
-  readonly roughness: number;
-  readonly alphaMode: "OPAQUE" | "BLEND" | "MASK";
-  readonly textureSet?: string;
-}
-
-export interface ProductManifest {
-  readonly schema: string;
-  readonly id: ProductAssetId;
-  readonly title: string;
-  readonly category: string;
-  readonly gltf: string;
-  readonly parts: readonly ProductPartDescriptor[];
-  readonly materials: readonly ProductMaterialDescriptor[];
-  readonly rejectedInputs?: readonly string[];
-  readonly requirements?: Readonly<Record<string, unknown>>;
-}
-
-export interface ProductAsset {
-  readonly id: ProductAssetId;
-  readonly title: string;
-  readonly category: string;
-  readonly url: string;
-  readonly manifest: ProductManifest;
-  readonly gltf: GLTFAsset;
-  readonly resources: GLTFRenderResources;
-  readonly parts: readonly ProductPartDescriptor[];
-  readonly materials: readonly ProductMaterialDescriptor[];
-}
-
-export interface ProductAssetLoadOptions {
-  readonly url: string;
-  readonly manifestUrl?: string;
-  readonly id?: ProductAssetId;
-  readonly title?: string;
-  readonly category?: string;
-}
-
-export interface ProductLightingConfig {
-  readonly preset: ProductLightingPreset;
-  readonly environmentLighting: EnvironmentLightingOptions;
-  readonly postprocess: RendererPostProcessOptions;
-  readonly shadow: RendererShadowOptions;
-  readonly lights: readonly CollectedLight[];
-}
-
-export interface ProductCameraFrame {
-  readonly preset: ProductCameraPreset;
-  readonly frame: PerspectiveCameraFrame;
-  readonly camera: CameraLike;
-}
-
-export interface ProductCameraOptions {
-  readonly preset?: ProductCameraPreset;
-  readonly viewport?: {
-    readonly width: number;
-    readonly height: number;
-  };
-  readonly paddingRatio?: number;
-}
-
-export interface ProductMaterialMode {
-  readonly id: ProductMaterialModeId;
-  readonly label: string;
-  readonly description: string;
-}
-
-export interface ProductRenderSceneOptions {
-  readonly lighting?: ProductLightingConfig;
-  readonly camera?: ProductCameraFrame;
-  readonly materialMode?: ProductMaterialMode;
-  readonly floor?: boolean;
-}
-
-export interface ProductRenderScene {
-  readonly asset: ProductAsset;
-  readonly source: RenderSource;
-  readonly camera: CameraLike;
-  readonly cameraFrame: ProductCameraFrame;
-  readonly lighting: ProductLightingConfig;
-  readonly materialMode: ProductMaterialMode;
-  readonly renderItems: readonly RenderItem[];
-}
-
-export interface ProductDiagnostics {
-  readonly assetId: ProductAssetId;
-  readonly partCount: number;
-  readonly materialCount: number;
-  readonly textureCount: number;
-  readonly meshCount: number;
-  readonly warnings: readonly string[];
-  readonly renderDiagnostics?: RenderDeviceDiagnostics;
-}
-
-export interface ProductSceneManifest {
-  readonly schema: "a3d-product-studio-scene";
-  readonly assetId: ProductAssetId;
-  readonly title: string;
-  readonly partCount: number;
-  readonly materialCount: number;
-  readonly materialMode: ProductMaterialModeId;
-  readonly lightingPreset: ProductLightingPreset;
-  readonly cameraPreset: ProductCameraPreset;
-  readonly generatedAt: string;
-}
-
-export interface ProductExportResult {
-  readonly mimeType: "image/png";
-  readonly dataUrl: string;
-  readonly byteLength: number;
-  readonly manifest: ProductSceneManifest;
-}
-
-export interface ProductStudioOptions extends RendererOptions {
-  readonly canvas?: HTMLCanvasElement | OffscreenCanvas;
-  readonly width?: number;
-  readonly height?: number;
-}
-
-export interface ProductStudio {
-  readonly renderer: Renderer;
-  render(scene: ProductRenderScene): RenderDeviceDiagnostics;
-  resize(width: number, height: number): void;
-  setLighting(preset: ProductLightingPreset): ProductLightingConfig;
-  setCamera(asset: ProductAsset, preset: ProductCameraPreset, viewport?: { readonly width: number; readonly height: number }): ProductCameraFrame;
-  setMaterialMode(mode: ProductMaterialModeId): ProductMaterialMode;
-  exportPng(scene: ProductRenderScene): Promise<ProductExportResult>;
-  exportSceneManifest(scene: ProductRenderScene): ProductSceneManifest;
-  dispose(): void;
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-export { loadProductAsset } from "./ProductAssetLoader";
-export { createProductCameraFrame, validateProductCameraFrame } from "./ProductCamera";
-export { createProductDiagnostics } from "./ProductDiagnostics";
-export { exportProductRender, exportProductSceneManifest } from "./ProductExport";
-export { createProductFloor } from "./ProductFloor";
-export { createProductLightingPreset } from "./ProductLighting";
-export { applyProductMaterialMode, createProductMaterialMode } from "./ProductMaterials";
-export { createProductRenderScene, updateProductRenderScene } from "./ProductRenderScene";
-export { createProductShowcaseLayout } from "./ProductShowcaseLayout";
-export { createProductStudio } from "./ProductStudio";
-export type * from "./ProductTypes";
-export type * from "./ProductShowcaseLayout";