@vgai/fal-client-compat 0.1.0 → 0.1.1

package/package.json

@@ -2,7 +2,7 @@
   "name": "@vgai/fal-client-compat",
   "author": "Volter AI, Inc.",
   "license": "Apache-2.0",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "description": "Native @fal-ai/client execution across direct, VGAI-managed, and deterministic mock transports.",
   "homepage": "https://github.com/volter-ai/vgai-engine#readme",

package/src/mock.ts

@@ -4,6 +4,8 @@ import type {
   HunyuanWorldImageToWorldOutput,
   HunyuanWorldInput,
   HunyuanWorldOutput,
+  MeshyV5RetextureInput,
+  MeshyV5RetextureOutput,
   MinimaxHailuo02StandardTextToVideoInput,
   MinimaxHailuo02StandardTextToVideoOutput,
   NanoBanana2EditInput,
@@ -30,6 +32,7 @@ const HAILUO_TEXT_TO_VIDEO_ENDPOINT = 'fal-ai/minimax/hailuo-02/standard/text-to
 const SEEDANCE_2_REFERENCE_TO_VIDEO_ENDPOINT = 'bytedance/seedance-2.0/reference-to-video';
 const HUNYUAN_IMAGE_TO_WORLD_ENDPOINT = 'fal-ai/hunyuan_world/image-to-world';
 const HUNYUAN_PANORAMA_ENDPOINT = 'fal-ai/hunyuan_world';
+const MESHY_V5_RETEXTURE_ENDPOINT = 'fal-ai/meshy/v5/retexture';
 const SUPPORTED_ENDPOINTS = new Set([
   NANO_BANANA_ENDPOINT,
   NANO_BANANA_EDIT_ENDPOINT,
@@ -41,6 +44,7 @@ const SUPPORTED_ENDPOINTS = new Set([
   SEEDANCE_2_REFERENCE_TO_VIDEO_ENDPOINT,
   HUNYUAN_IMAGE_TO_WORLD_ENDPOINT,
   HUNYUAN_PANORAMA_ENDPOINT,
+  MESHY_V5_RETEXTURE_ENDPOINT,
 ]);
 const EXECUTION_RECORDER = Symbol.for('vgai.generative-execution-recorder.v1');
 
@@ -64,7 +68,8 @@ type MockTask = {
     | MinimaxHailuo02StandardTextToVideoOutput
     | Seedance2VideoOutput
     | HunyuanWorldImageToWorldOutput
-    | HunyuanWorldOutput;
+    | HunyuanWorldOutput
+    | MeshyV5RetextureOutput;
 };
 
 // Four tiny, real VP8/WebM motion designs. Request hash chooses the visible
@@ -907,6 +912,194 @@ function createHunyuanPanoramaOutput(input: HunyuanWorldInput): HunyuanWorldOutp
   };
 }
 
+function pad(bytes: Uint8Array, multiple: number, fill = 0): Uint8Array {
+  const paddedLength = Math.ceil(bytes.byteLength / multiple) * multiple;
+  if (paddedLength === bytes.byteLength) return bytes;
+  const output = new Uint8Array(paddedLength);
+  output.fill(fill);
+  output.set(bytes);
+  return output;
+}
+
+function uint32LittleEndian(value: number): Uint8Array {
+  const bytes = new Uint8Array(4);
+  new DataView(bytes.buffer).setUint32(0, value, true);
+  return bytes;
+}
+
+function glbChunk(type: number, data: Uint8Array): Uint8Array {
+  return concatBytes([uint32LittleEndian(data.byteLength), uint32LittleEndian(type), data]);
+}
+
+function floatBytes(values: Float32Array): Uint8Array {
+  return new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+}
+
+function uint16Bytes(values: Uint16Array): Uint8Array {
+  return new Uint8Array(values.buffer, values.byteOffset, values.byteLength);
+}
+
+function mockTextureImage(canonicalInput: string, hash: Uint8Array): Uint8Array {
+  const size = 64;
+  const pixels = new Uint8Array(size * size * 4);
+  fillBackground(pixels, size, size, hash);
+  drawText(pixels, size, size, 'MESHY', 4, 6, 1, [255, 255, 255, 255]);
+  return encodePng(size, size, pixels, canonicalInput);
+}
+
+/**
+ * A retexture result the accept path can actually check: a hash-derived box
+ * carrying a TEXCOORD_0 set, a real PNG image, and a baseColorTexture. Its
+ * geometry is deliberately the mock's OWN and not the submitted model's — a
+ * mock that echoed the input topology would answer, with fabricated data, the
+ * one question only a real Meshy run can answer.
+ */
+function createMockRetexturedGlb(canonicalInput: string): Uint8Array {
+  const hash = hashBytes(canonicalInput);
+  const halfX = 0.35 + ((hash[0] ?? 0) / 255) * 0.45;
+  const halfY = 0.35 + ((hash[1] ?? 0) / 255) * 0.65;
+  const halfZ = 0.35 + ((hash[2] ?? 0) / 255) * 0.45;
+  const corners: Array<[number, number, number]> = [
+    [-halfX, -halfY, -halfZ],
+    [halfX, -halfY, -halfZ],
+    [halfX, -halfY, halfZ],
+    [-halfX, -halfY, halfZ],
+    [-halfX, halfY, -halfZ],
+    [halfX, halfY, -halfZ],
+    [halfX, halfY, halfZ],
+    [-halfX, halfY, halfZ],
+  ];
+  const positions = new Float32Array(corners.flat());
+  const uvs = new Float32Array(
+    corners.map(([x, , z]) => [(x + halfX) / (2 * halfX), (z + halfZ) / (2 * halfZ)]).flat(),
+  );
+  const indices = new Uint16Array([
+    0, 2, 1, 0, 3, 2, 4, 5, 6, 4, 6, 7, 0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 0,
+    4, 3, 4, 7,
+  ]);
+  const bufferViews: Array<Record<string, number>> = [];
+  const parts: Uint8Array[] = [];
+  let byteOffset = 0;
+  const addView = (bytes: Uint8Array, target?: number): number => {
+    const index = bufferViews.length;
+    bufferViews.push({
+      buffer: 0,
+      byteOffset,
+      byteLength: bytes.byteLength,
+      ...(target ? { target } : {}),
+    });
+    const padded = pad(bytes, 4);
+    parts.push(padded);
+    byteOffset += padded.byteLength;
+    return index;
+  };
+  const positionView = addView(floatBytes(positions), 34962);
+  const uvView = addView(floatBytes(uvs), 34962);
+  const indexView = addView(uint16Bytes(indices), 34963);
+  const imageView = addView(mockTextureImage(canonicalInput, hash));
+  const binary = concatBytes(parts);
+  const document = {
+    asset: {
+      version: '2.0',
+      generator: '@vgai/fal-client-compat deterministic retexture mock',
+      extras: {
+        vgaiMock: true,
+        provider: 'fal',
+        canonicalInput,
+        hash: hex(hash),
+        geometryIsSubstitute: true,
+      },
+    },
+    scene: 0,
+    scenes: [{ name: 'VGAI Meshy Retexture Mock', nodes: [0] }],
+    nodes: [{ mesh: 0, name: 'VGAI MOCK retextured', extras: { vgaiMock: true } }],
+    meshes: [
+      {
+        name: 'Hash-derived textured mock geometry',
+        primitives: [{ attributes: { POSITION: 0, TEXCOORD_0: 1 }, indices: 2, material: 0 }],
+      },
+    ],
+    materials: [
+      {
+        name: 'Hash-derived base color texture',
+        pbrMetallicRoughness: {
+          baseColorTexture: { index: 0, texCoord: 0 },
+          metallicFactor: 0,
+          roughnessFactor: 0.8,
+        },
+      },
+    ],
+    textures: [{ source: 0, sampler: 0 }],
+    samplers: [{ magFilter: 9729, minFilter: 9987, wrapS: 10497, wrapT: 10497 }],
+    images: [{ bufferView: imageView, mimeType: 'image/png', name: 'vgai-mock-basecolor' }],
+    accessors: [
+      {
+        bufferView: positionView,
+        componentType: 5126,
+        count: corners.length,
+        type: 'VEC3',
+        min: [-halfX, -halfY, -halfZ],
+        max: [halfX, halfY, halfZ],
+      },
+      { bufferView: uvView, componentType: 5126, count: corners.length, type: 'VEC2' },
+      { bufferView: indexView, componentType: 5123, count: indices.length, type: 'SCALAR' },
+    ],
+    bufferViews,
+    buffers: [{ byteLength: binary.byteLength }],
+  };
+  const json = pad(new TextEncoder().encode(JSON.stringify(document)), 4, 0x20);
+  const jsonChunk = glbChunk(0x4e4f534a, json);
+  const binaryChunk = glbChunk(0x004e4942, binary);
+  return concatBytes([
+    uint32LittleEndian(0x46546c67),
+    uint32LittleEndian(2),
+    uint32LittleEndian(12 + jsonChunk.byteLength + binaryChunk.byteLength),
+    jsonChunk,
+    binaryChunk,
+  ]);
+}
+
+function createMeshyRetextureOutput(input: MeshyV5RetextureInput): MeshyV5RetextureOutput {
+  if (!input || typeof input.model_url !== 'string' || input.model_url.trim().length === 0) {
+    throw new Error(
+      'fal mock: fal-ai/meshy/v5/retexture requires input.model_url as a non-empty URL or data URI.',
+    );
+  }
+  const styled =
+    (typeof input.text_style_prompt === 'string' && input.text_style_prompt.trim().length > 0) ||
+    (typeof input.image_style_url === 'string' && input.image_style_url.trim().length > 0);
+  if (!styled) {
+    throw new Error(
+      'fal mock: fal-ai/meshy/v5/retexture requires input.text_style_prompt or input.image_style_url.',
+    );
+  }
+  // The submitted model is usually a multi-megabyte data URI. Identify it by
+  // digest so the deterministic identity stays cheap and the embedded record
+  // stays small, while still differing for different models.
+  const canonicalInput = stableJson({
+    endpoint: MESHY_V5_RETEXTURE_ENDPOINT,
+    input: { ...input, model_url: `sha:${hex(hashBytes(input.model_url))}` },
+  });
+  const glb = createMockRetexturedGlb(canonicalInput);
+  const digest = hex(hashBytes(base64(glb))).slice(0, 16);
+  const model = {
+    url: `data:application/octet-stream;base64,${base64(glb)}`,
+    content_type: 'model/gltf-binary',
+    file_name: `vgai-mock-${digest}.glb`,
+    file_size: glb.byteLength,
+  };
+  return {
+    model_glb: model,
+    model_urls: { glb: model },
+    ...(typeof input.text_style_prompt === 'string'
+      ? { text_style_prompt: input.text_style_prompt }
+      : {}),
+    ...(typeof input.image_style_url === 'string'
+      ? { image_style_url: input.image_style_url }
+      : {}),
+  };
+}
+
 function createOutput(
   endpoint: string,
   input:
@@ -919,7 +1112,8 @@ function createOutput(
     | MinimaxHailuo02StandardTextToVideoInput
     | Seedance2R2VInput
     | HunyuanWorldImageToWorldInput
-    | HunyuanWorldInput,
+    | HunyuanWorldInput
+    | MeshyV5RetextureInput,
 ):
   | NanoBananaOutput
   | StableAudioOutput
@@ -927,7 +1121,8 @@ function createOutput(
   | MinimaxHailuo02StandardTextToVideoOutput
   | Seedance2VideoOutput
   | HunyuanWorldImageToWorldOutput
-  | HunyuanWorldOutput {
+  | HunyuanWorldOutput
+  | MeshyV5RetextureOutput {
   if (
     endpoint === NANO_BANANA_ENDPOINT ||
     endpoint === NANO_BANANA_EDIT_ENDPOINT ||
@@ -954,6 +1149,9 @@ function createOutput(
   if (endpoint === HUNYUAN_PANORAMA_ENDPOINT) {
     return createHunyuanPanoramaOutput(input as HunyuanWorldInput);
   }
+  if (endpoint === MESHY_V5_RETEXTURE_ENDPOINT) {
+    return createMeshyRetextureOutput(input as MeshyV5RetextureInput);
+  }
   throw new Error(`fal mock: endpoint ${JSON.stringify(endpoint)} is not implemented.`);
 }
 
@@ -993,7 +1191,8 @@ function submitTask(
       | MinimaxHailuo02StandardTextToVideoInput
       | Seedance2R2VInput
       | HunyuanWorldImageToWorldInput
-      | HunyuanWorldInput,
+      | HunyuanWorldInput
+      | MeshyV5RetextureInput,
   );
   const requestId = `mock_${hex(hashBytes(stableJson({ endpoint, body }))).slice(0, 24)}`;
   tasks.set(requestId, { endpoint, output });