@agent-native/core-corpus 0.214.0 → 0.216.0

package/corpus/templates/design/shared/effect-graph.ts

@@ -47,6 +47,44 @@ export interface EffectPass {
   draw?:
     | { vertices: 6; instances: "simulation-count" }
     | EffectStatefulResourceDraw;
+  mesh?: EffectMeshSpec;
+}
+
+export interface EffectMeshSpec {
+  columns: number;
+  rows: number;
+}
+
+export function isEffectMeshSpec(value: unknown): value is EffectMeshSpec {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const mesh = value as Record<string, unknown>;
+  return (
+    Object.keys(mesh).length === 2 &&
+    Number.isSafeInteger(mesh.columns) &&
+    Number.isSafeInteger(mesh.rows) &&
+    (mesh.columns as number) >= 16 &&
+    (mesh.columns as number) <= 256 &&
+    (mesh.rows as number) >= 16 &&
+    (mesh.rows as number) <= 256 &&
+    (mesh.columns as number) * (mesh.rows as number) <= 32_768
+  );
+}
+
+export function isEffectMeshPassCompatible(
+  pass: EffectPass,
+  specializedGraph: boolean,
+): boolean {
+  return (
+    isEffectMeshSpec(pass.mesh) &&
+    pass.kind === "render" &&
+    pass.draw === undefined &&
+    pass.dispatch === undefined &&
+    pass.persistent === undefined &&
+    pass.previousFrameReads === undefined &&
+    pass.additionalOutputs === undefined &&
+    pass.original === undefined &&
+    !specializedGraph
+  );
 }
 
 export interface EffectFeedbackSpec {
@@ -341,7 +379,14 @@ export function planEffectPasses(
                 resourceGraph?.abi === "stateful-resource-v3") &&
               isStatefulResourceDraw(pass.draw)
             )) ||
-          Object.keys(pass.draw).length !== 2))
+          Object.keys(pass.draw).length !== 2)) ||
+      (pass.mesh !== undefined &&
+        !isEffectMeshPassCompatible(
+          pass,
+          feedback !== undefined ||
+            statelessCompute !== undefined ||
+            resourceGraph !== undefined,
+        ))
     ) {
       errors.push(`pass[${index}] is malformed`);
     }

package/corpus/templates/design/shared/generation-output-receipt.ts

@@ -27,7 +27,6 @@ export const DESIGN_OUTPUT_ACTIONS = new Set([
   "apply-a11y-fix",
   "apply-component-prop-edit",
   "apply-motion-edit",
-  "apply-shader-fill",
   "apply-source-edit",
   "apply-visual-edit",
   "clone-creative-context-design",

package/corpus/templates/design/shared/native-effect-animation-capability.ts

@@ -310,6 +310,9 @@ const STATIC_BUILTIN_VERSIONS = new Set([
 ]);
 
 const ANIMATED_BUILTIN_VERSIONS = new Set([
+  "an-native-folded-mesh@1",
+  "an-native-folded-mesh@2",
+  "an-native-folded-mesh@3",
   "an-native-liquid-metal@1",
   "an-native-liquid-metal@2",
   "an-native-liquid-metal@3",
@@ -337,6 +340,9 @@ const ANIMATED_BUILTIN_VERSIONS = new Set([
   "an-native-perlin-noise@1",
   "an-native-simplex-noise@1",
   "an-native-pulsing-border@1",
+  "an-native-pulsing-border@3",
+  "an-native-pulsing-border@4",
+  "an-native-pulsing-border@5",
   "an-native-color-panels@1",
   "an-native-smoke-ring@1",
   "an-native-god-rays@1",

package/corpus/templates/design/shared/native-effect-folded-mesh-v1.ts

@@ -0,0 +1,268 @@
+import type { EffectDefinition } from "./native-effects";
+
+export const FOLDED_MESH_V1_EFFECT: EffectDefinition = {
+  id: "an-native-folded-mesh",
+  name: "Folded Mesh",
+  version: 1,
+  kind: "generator",
+  placements: ["fill"],
+  properties: {
+    fill: {
+      type: "paint",
+      label: "Fill",
+      maxCount: 8,
+      default: {
+        kind: "linear",
+        angle: 112,
+        interpolation: "in oklab",
+        stops: [
+          {
+            position: 0,
+            color: {
+              space: "srgb",
+              components: [0.23, 0.07, 0.52],
+              alpha: 1,
+            },
+          },
+          {
+            position: 0.34,
+            color: {
+              space: "srgb",
+              components: [0.73, 0.16, 0.68],
+              alpha: 1,
+            },
+          },
+          {
+            position: 0.68,
+            color: {
+              space: "srgb",
+              components: [0.99, 0.36, 0.39],
+              alpha: 1,
+            },
+          },
+          {
+            position: 1,
+            color: {
+              space: "srgb",
+              components: [1, 0.72, 0.36],
+              alpha: 1,
+            },
+          },
+        ],
+      },
+    },
+    scale: {
+      type: "float",
+      label: "Scale",
+      default: 1,
+      min: 0.5,
+      max: 2,
+      step: 0.01,
+    },
+    twist: {
+      type: "float",
+      label: "Twist",
+      default: 0.65,
+      min: -3.141592653589793,
+      max: 3.141592653589793,
+      step: 0.01,
+    },
+    depth: {
+      type: "float",
+      label: "Depth",
+      default: 0.62,
+      min: 0,
+      max: 1,
+      step: 0.01,
+    },
+    softness: {
+      type: "float",
+      label: "Softness",
+      default: 0.3,
+      min: 0,
+      max: 1,
+      step: 0.01,
+    },
+  },
+  outputs: {
+    color: {
+      kind: "texture-2d",
+      resource: "color",
+    },
+  },
+  resources: [
+    {
+      name: "color",
+      kind: "texture-2d",
+      format: "rgba16float",
+      usage: ["render", "sampled"],
+      size: "viewport",
+    },
+  ],
+  output: "color",
+  passes: [
+    {
+      id: "folded-surface",
+      kind: "render",
+      reads: [],
+      output: "color",
+      mesh: {
+        columns: 128,
+        rows: 96,
+      },
+      wgsl: `
+struct Globals {
+  viewport: vec4f,
+  clock: vec4f,
+  params: array<vec4f, 32>,
+};
+@group(0) @binding(0) var<uniform> globals: Globals;
+@group(0) @binding(1) var effectSampler: sampler;
+@group(0) @binding(2) var sourceTexture: texture_2d<f32>;
+@group(0) @binding(3) var maskTexture: texture_2d<f32>;
+
+
+fn foldedFillEncode(c: vec3f) -> vec3f {
+  let magnitude = abs(c);
+  return sign(c) * select(1.055 * pow(magnitude, vec3f(1.0 / 2.4)) - 0.055, magnitude * 12.92, magnitude <= vec3f(0.0031308));
+}
+fn foldedFillDecode(c: vec3f) -> vec3f {
+  let magnitude = abs(c);
+  return sign(c) * select(pow((magnitude + 0.055) / 1.055, vec3f(2.4)), magnitude / 12.92, magnitude <= vec3f(0.04045));
+}
+fn foldedFillToSpace(rgb: vec3f, mode: u32) -> vec3f {
+  if (mode == 1u) { return rgb; }
+  if (mode == 2u) {
+    let lms = vec3f(dot(rgb, vec3f(0.4122214708, 0.5363325363, 0.0514459929)), dot(rgb, vec3f(0.2119034982, 0.6806995451, 0.1073969566)), dot(rgb, vec3f(0.0883024619, 0.2817188376, 0.6299787005)));
+    let root = sign(lms) * pow(abs(lms), vec3f(1.0 / 3.0));
+    return vec3f(dot(root, vec3f(0.2104542553, 0.7936177850, -0.0040720468)), dot(root, vec3f(1.9779984951, -2.4285922050, 0.4505937099)), dot(root, vec3f(0.0259040371, 0.7827717662, -0.8086757660)));
+  }
+  if (mode == 3u) {
+    return foldedFillEncode(vec3f(dot(rgb, vec3f(0.8224620106, 0.1775379894, 0.0)), dot(rgb, vec3f(0.0331941591, 0.9668058409, 0.0)), dot(rgb, vec3f(0.0170826307, 0.0723974407, 0.9105199286))));
+  }
+  return foldedFillEncode(rgb);
+}
+fn foldedFillFromSpace(value: vec3f, mode: u32) -> vec3f {
+  if (mode == 1u) { return value; }
+  if (mode == 2u) {
+    let root = vec3f(value.x + 0.3963377774 * value.y + 0.2158037573 * value.z, value.x - 0.1055613458 * value.y - 0.0638541728 * value.z, value.x - 0.0894841775 * value.y - 1.2914855480 * value.z);
+    let lms = root * root * root;
+    return vec3f(dot(lms, vec3f(4.0767416621, -3.3077115913, 0.2309699292)), dot(lms, vec3f(-1.2684380046, 2.6097574011, -0.3413193965)), dot(lms, vec3f(-0.0041960863, -0.7034186147, 1.7076147010)));
+  }
+  let rgb = foldedFillDecode(value);
+  if (mode == 3u) {
+    return vec3f(1.2249401 * rgb.r - 0.2249401 * rgb.g, -0.0420569 * rgb.r + 1.0420569 * rgb.g, -0.0196376 * rgb.r - 0.0786361 * rgb.g + 1.0982737 * rgb.b);
+  }
+  return rgb;
+}
+fn foldedFill(uv: vec2f, viewport: vec2f) -> vec4f {
+  let header = globals.params[0];
+  let encoded = u32(header.x);
+  let kind = encoded % 8u;
+  let mode = encoded / 8u;
+  let count = min(u32(header.y), 8u);
+  let first = globals.params[1];
+  if (kind == 0u) { return vec4f(first.rgb * first.a, first.a); }
+  let size = max(viewport, vec2f(0.0001));
+  let pixel = (uv - 0.5) * size;
+  var position = 0.0;
+  if (kind == 1u) {
+    let direction = vec2f(sin(header.z), -cos(header.z));
+    let span = dot(abs(direction), size);
+    position = 0.5 + dot(pixel, direction) / max(span, 0.0001);
+  } else if (kind == 2u) {
+    position = length(pixel) / max(length(size * 0.5), 0.0001);
+  } else if (kind == 3u) {
+    position = fract((atan2(pixel.x, -pixel.y) - header.z) / 6.283185307179586 + 1.0);
+  } else {
+    position = length((uv - 0.5) * 2.0);
+  }
+  position = clamp(position, 0.0, 1.0);
+  var lower = first;
+  var upper = first;
+  var lowerPosition = globals.params[2].x;
+  var upperPosition = lowerPosition;
+  for (var i = 1u; i < count; i += 1u) {
+    let color = globals.params[1u + i * 2u];
+    let stopPosition = globals.params[2u + i * 2u].x;
+    if (stopPosition <= position) {
+      lower = color;
+      lowerPosition = stopPosition;
+      upper = color;
+      upperPosition = stopPosition;
+    } else {
+      upper = color;
+      upperPosition = stopPosition;
+      break;
+    }
+  }
+  if (position <= lowerPosition || upperPosition <= lowerPosition) { return vec4f(lower.rgb * lower.a, lower.a) * header.w; }
+  let weight = clamp((position - lowerPosition) / (upperPosition - lowerPosition), 0.0, 1.0);
+  let alpha = mix(lower.a, upper.a, weight);
+  let premultiplied = mix(foldedFillToSpace(lower.rgb, mode) * lower.a, foldedFillToSpace(upper.rgb, mode) * upper.a, weight);
+  if (alpha == 0.0) { return vec4f(0.0); }
+  return vec4f(foldedFillFromSpace(premultiplied / alpha, mode) * alpha, alpha) * header.w;
+}
+
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) world: vec3f,
+  @location(2) ridge: f32,
+};
+@vertex fn vs(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  let uv = vec2f(f32(vertexIndex % 129u), f32(vertexIndex / 129u)) / vec2f(128.0, 96.0);
+  let aspect = globals.viewport.x / max(globals.viewport.y, 1.0);
+  let scale = globals.params[17].x;
+  let twist = globals.params[18].x;
+  let depth = globals.params[19].x;
+  let softness = globals.params[20].x;
+  let time = globals.clock.x;
+  let plane = vec2f((uv.x - 0.5) * aspect, 0.5 - uv.y) * (2.85 / scale);
+  let diagonal = plane.x * 3.4 + plane.y * 1.15 + 0.22 * sin(plane.y * 3.1 + time * 0.42);
+  let fold = sin(diagonal + time * 0.28);
+  let fine = sin(diagonal * 2.0 - plane.y * 0.7 + time * 0.36);
+  let relief = depth * (0.34 * fold + (0.19 - 0.11 * softness) * fine);
+  let turn = twist * plane.y * 0.65 + 0.13 * sin(time * 0.38 + plane.y * 1.8);
+  let world = vec3f(
+    plane.x * cos(turn) - relief * sin(turn),
+    plane.y + depth * 0.06 * sin(plane.x * 2.3 + time * 0.47),
+    plane.x * sin(turn) + relief * cos(turn)
+  );
+  let camera = 3.0 + 1.5 * max(aspect, 1.0) / scale;
+  let viewDepth = camera - world.z;
+  let nearPlane = 0.1;
+  let farPlane = camera * 2.5;
+  var output: VertexOutput;
+  output.position = vec4f(
+    world.x * camera / aspect,
+    world.y * camera,
+    farPlane / (farPlane - nearPlane) * viewDepth - farPlane * nearPlane / (farPlane - nearPlane),
+    viewDepth
+  );
+  output.uv = uv;
+  output.world = world;
+  output.ridge = fold;
+  return output;
+}
+@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+  let paint = foldedFill(input.uv, globals.viewport.xy);
+  let surface = cross(dpdx(input.world), dpdy(input.world));
+  let oriented = select(surface, -surface, surface.z < 0.0);
+  let normal = oriented / max(length(oriented), 1e-12);
+  let light = normalize(vec3f(-0.42, 0.56, 0.72));
+  let diffuse = max(dot(normal, light), 0.0);
+  let highlight = pow(diffuse, 18.0);
+  let crease = 1.0 - 0.11 * (1.0 - abs(input.ridge));
+  let illumination = (0.47 + 0.68 * diffuse) * crease;
+  let rgb = paint.rgb * illumination + vec3f(0.15 * highlight * paint.a);
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(1.0)), paint.a);
+}
+`,
+    },
+  ],
+  provenance: {
+    origin: "design-original",
+    note: "Original vertex-deformed folded surface with packed native paint.",
+  },
+};

package/corpus/templates/design/shared/native-effect-folded-mesh-v2.ts

@@ -0,0 +1,310 @@
+import { catalogColor, catalogFloat } from "./native-effect-catalog-kit";
+import { nativeEffectPaintWgsl } from "./native-effect-paint";
+import { NATIVE_GLOBAL_BINDINGS } from "./native-effect-wgsl";
+import {
+  planNativePropertyLayout,
+  type EffectDefinition,
+} from "./native-effects";
+
+const fill = {
+  type: "paint" as const,
+  label: "Fill",
+  maxCount: 8,
+  default: {
+    kind: "linear" as const,
+    angle: 90,
+    interpolation: "in oklab" as const,
+    stops: [
+      { position: 0, color: catalogColor(0.52, 0.65, 1) },
+      { position: 0.24, color: catalogColor(0.94, 0.42, 0.91) },
+      { position: 0.36, color: catalogColor(1, 0.38, 0.48) },
+      { position: 0.49, color: catalogColor(1, 0.88, 0.25) },
+      { position: 0.68, color: catalogColor(1, 0.48, 0.14) },
+      { position: 1, color: catalogColor(0.96, 0.33, 0.54) },
+    ],
+  },
+};
+
+function groupedFloat(group: string, ...args: Parameters<typeof catalogFloat>) {
+  return { ...catalogFloat(...args), group };
+}
+
+const properties = {
+  fill,
+  timeOffset: groupedFloat("Motion", "Time offset", 0, -30, 30),
+  contrast: groupedFloat("Color", "Contrast", 1, 0, 2),
+  saturation: groupedFloat("Color", "Saturation", 1, 0, 2),
+  hueShift: groupedFloat("Color", "Hue shift", 0, -2 * Math.PI, 2 * Math.PI),
+  displacementAmount: groupedFloat("Shape", "Displacement amount", 0.62, 0, 1),
+  displacementFrequencyX: groupedFloat(
+    "Shape",
+    "Displacement frequency X",
+    12.7,
+    0,
+    20,
+    0.1,
+  ),
+  displacementFrequencyY: groupedFloat(
+    "Shape",
+    "Displacement frequency Y",
+    1.1,
+    0,
+    20,
+    0.1,
+  ),
+  positionX: groupedFloat("Transform", "Position X", 0, -2, 2),
+  positionY: groupedFloat("Transform", "Position Y", 0, -2, 2),
+  positionZ: groupedFloat("Transform", "Position Z", 0, -2, 2),
+  rotationX: groupedFloat(
+    "Transform",
+    "Rotation X",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  rotationY: groupedFloat(
+    "Transform",
+    "Rotation Y",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  rotationZ: groupedFloat(
+    "Transform",
+    "Rotation Z",
+    0,
+    -2 * Math.PI,
+    2 * Math.PI,
+  ),
+  scaleX: groupedFloat("Transform", "Scale X", 1, 0.25, 3),
+  scaleY: groupedFloat("Transform", "Scale Y", 1, 0.25, 3),
+  scaleZ: groupedFloat("Transform", "Scale Z", 1, 0.25, 3),
+  twistX: groupedFloat("Shape", "Twist X", 0.62, -2 * Math.PI, 2 * Math.PI),
+  twistY: groupedFloat("Shape", "Twist Y", 2, -2 * Math.PI, 2 * Math.PI),
+  twistZ: groupedFloat("Shape", "Twist Z", 0, -2 * Math.PI, 2 * Math.PI),
+  foldConcentrationX: groupedFloat("Shape", "Fold tightness X", 0.5, 0, 1),
+  foldConcentrationY: groupedFloat("Shape", "Fold tightness Y", 0.12, 0, 1),
+  foldConcentrationZ: groupedFloat("Shape", "Fold tightness Z", 0.5, 0, 1),
+  glowAmount: groupedFloat("Surface", "Glow amount", 0.45, 0, 2),
+  glowSpread: groupedFloat("Surface", "Glow spread", 0.45, 0, 1),
+  glowFocus: groupedFloat("Surface", "Glow focus", 0.5, 0, 1),
+  lineDensity: groupedFloat("Surface", "Line density", 300, 0, 600, 1),
+  lineThickness: groupedFloat("Surface", "Line thickness", 0.5, 0, 1),
+  compressionResponse: groupedFloat("Surface", "Compression response", 1, 0, 2),
+};
+
+const propertyLayout = planNativePropertyLayout({
+  properties,
+  uniformPacking: "compact",
+});
+if (propertyLayout.offsets.fill !== 0)
+  throw new Error("Folded Mesh paint must start at uniform zero");
+
+function nativeParam(name: keyof typeof properties): string {
+  const offset = propertyLayout.offsets[name];
+  if (offset === undefined)
+    throw new Error(`Folded Mesh property ${name} is unbound`);
+  return `globals.params[${Math.floor(offset / 4)}].${"xyzw"[offset % 4]}`;
+}
+
+export const FOLDED_MESH_V2_EFFECT: EffectDefinition = {
+  id: "an-native-folded-mesh",
+  name: "Folded Mesh",
+  version: 2,
+  kind: "generator",
+  placements: ["fill"],
+  uniformPacking: "compact",
+  properties,
+  outputs: { color: { kind: "texture-2d", resource: "color" } },
+  resources: [
+    {
+      name: "color",
+      kind: "texture-2d",
+      format: "rgba16float",
+      usage: ["render", "sampled"],
+      size: "viewport",
+    },
+  ],
+  output: "color",
+  passes: [
+    {
+      id: "folded-surface",
+      kind: "render",
+      reads: [],
+      output: "color",
+      mesh: { columns: 128, rows: 96 },
+      wgsl: `${NATIVE_GLOBAL_BINDINGS}
+${nativeEffectPaintWgsl(propertyLayout.offsets.fill / 4, "foldedFill")}
+struct VertexOutput {
+  @builtin(position) position: vec4f,
+  @location(0) uv: vec2f,
+  @location(1) normal: vec3f,
+  @location(2) seam: f32,
+  @location(3) @interpolate(flat) hueRotation: vec2f,
+};
+fn rotateX(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x, value.y * cosine - value.z * sine, value.y * sine + value.z * cosine);
+}
+fn rotateY(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x * cosine + value.z * sine, value.y, -value.x * sine + value.z * cosine);
+}
+fn rotateZ(value: vec3f, sine: f32, cosine: f32) -> vec3f {
+  return vec3f(value.x * cosine - value.y * sine, value.x * sine + value.y * cosine, value.z);
+}
+@vertex fn vs(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
+  let uv = vec2f(f32(vertexIndex % 129u), f32(vertexIndex / 129u)) / vec2f(128.0, 96.0);
+  let aspect = globals.viewport.x / max(globals.viewport.y, 1.0);
+  let size = 0.68;
+  let twistX = ${nativeParam("twistX")};
+  let twistY = ${nativeParam("twistY")};
+  let twistZ = ${nativeParam("twistZ")};
+  let depth = ${nativeParam("displacementAmount")};
+  let frequencyX = ${nativeParam("displacementFrequencyX")};
+  let frequencyY = ${nativeParam("displacementFrequencyY")};
+  let foldX = ${nativeParam("foldConcentrationX")};
+  let foldY = ${nativeParam("foldConcentrationY")};
+  let foldZ = ${nativeParam("foldConcentrationZ")};
+  let time = globals.clock.x + ${nativeParam("timeOffset")};
+  let deformationStrength = clamp(max(length(vec3f(twistX, twistY, twistZ)) / 2.094, depth / 0.62), 0.0, 1.0);
+  let s = uv.y;
+  let t = uv.x * 2.0 - 1.0;
+  let foldRadius = 0.05 + 0.16 * (1.0 - foldX);
+  let foldEnvelope = exp(-t * t / foldRadius);
+  let foldEnvelopeT = -2.0 * t * foldEnvelope / foldRadius;
+  let foldStrength = 0.85 + 0.66 * foldZ;
+  let foldedT = t - deformationStrength * foldStrength * t * foldEnvelope;
+  let foldedTT = 1.0 - deformationStrength * foldStrength * (foldEnvelope + t * foldEnvelopeT);
+  let pleatPhase = 6.2831853 * (frequencyX * uv.x + frequencyY * s) + time * 0.3;
+  let broadPhase = 5.0 * t + 2.0 * s + time * 0.2;
+  let pleatWeight = 0.025;
+  let ridgeHeight = 0.08 + 0.12 * foldZ;
+  let relief = depth * size * (ridgeHeight * foldEnvelope + pleatWeight * sin(pleatPhase) + 0.04 * sin(broadPhase));
+  let reliefT = depth * size * (ridgeHeight * foldEnvelopeT + 3.14159265 * frequencyX * pleatWeight * cos(pleatPhase) + 0.2 * cos(broadPhase));
+  let reliefS = depth * size * (6.2831853 * frequencyY * pleatWeight * cos(pleatPhase) + 0.08 * cos(broadPhase));
+  let across = 1.55 * aspect * size;
+  let tailPosition = clamp((s - 0.58) / 0.42, 0.0, 1.0);
+  let tail = tailPosition * tailPosition * (3.0 - 2.0 * tailPosition);
+  let tailS = select(0.0, 6.0 * tailPosition * (1.0 - tailPosition) / 0.42, s > 0.58 && s < 1.0);
+  let longitudinal = (1.75 - 3.3 * s - 1.35 * tail) * size;
+  let base = vec3f(across * foldedT, longitudinal, relief);
+  let baseT = vec3f(across * foldedTT, 0.0, reliefT);
+  let baseS = vec3f(0.0, (-3.3 - 1.35 * tailS) * size, reliefS);
+  let turnWidth = 1.0 - 0.75 * foldY;
+  let turnStart = 0.5 - 0.5 * turnWidth;
+  let turnEnd = 0.5 + 0.5 * turnWidth;
+  let turnPosition = clamp((s - turnStart) / turnWidth, 0.0, 1.0);
+  let turnProfile = turnPosition * turnPosition * (3.0 - 2.0 * turnPosition);
+  let turnProfileS = select(0.0, 6.0 * turnPosition * (1.0 - turnPosition) / turnWidth, s > turnStart && s < turnEnd);
+  let hingeRadius = 0.09 + 0.32 * (1.0 - foldX);
+  let hingeEnvelope = exp(-t * t / hingeRadius);
+  let hingeEnvelopeT = -2.0 * t * hingeEnvelope / hingeRadius;
+  let hingePhase = 3.14159265 * s + time * 0.14;
+  let hingeStrength = (0.5 + 0.9 * foldZ) * twistY / 2.0;
+  let hinge = hingeStrength * t * hingeEnvelope * sin(hingePhase);
+  let hingeT = hingeStrength * (hingeEnvelope + t * hingeEnvelopeT) * sin(hingePhase);
+  let hingeS = hingeStrength * t * hingeEnvelope * 3.14159265 * cos(hingePhase);
+  let turn = twistY * turnProfile + hinge;
+  let turnT = hingeT;
+  let turnS = twistY * turnProfileS + hingeS;
+  let sinTurn = sin(turn);
+  let cosTurn = cos(turn);
+  let turned = vec3f(base.x * cosTurn + base.z * sinTurn, base.y, -base.x * sinTurn + base.z * cosTurn);
+  let turnedT = vec3f(baseT.x * cosTurn + baseT.z * sinTurn, baseT.y, -baseT.x * sinTurn + baseT.z * cosTurn)
+    + turnT * vec3f(turned.z, 0.0, -turned.x);
+  let turnedS = vec3f(baseS.x * cosTurn + baseS.z * sinTurn, baseS.y, -baseS.x * sinTurn + baseS.z * cosTurn)
+    + turnS * vec3f(turned.z, 0.0, -turned.x);
+  let curlEnvelope = exp(-t * t / 0.4);
+  let curlEnvelopeT = -2.0 * t * curlEnvelope / 0.4;
+  let curlPhase = 3.14159265 * s + time * 0.12;
+  let bend = twistX * (0.8 * t * curlEnvelope * sin(curlPhase) + 0.22 * sin(2.0 * s + time * 0.15));
+  let bendT = twistX * 0.8 * (curlEnvelope + t * curlEnvelopeT) * sin(curlPhase);
+  let bendS = twistX * (0.8 * t * curlEnvelope * 3.14159265 * cos(curlPhase) + 0.44 * cos(2.0 * s + time * 0.15));
+  let sinBend = sin(bend);
+  let cosBend = cos(bend);
+  let curled = vec3f(turned.x, turned.y * cosBend - turned.z * sinBend, turned.y * sinBend + turned.z * cosBend);
+  let curledT = vec3f(turnedT.x, turnedT.y * cosBend - turnedT.z * sinBend, turnedT.y * sinBend + turnedT.z * cosBend)
+    + bendT * vec3f(0.0, -curled.z, curled.y);
+  let curledS = vec3f(turnedS.x, turnedS.y * cosBend - turnedS.z * sinBend, turnedS.y * sinBend + turnedS.z * cosBend)
+    + bendS * vec3f(0.0, -curled.z, curled.y);
+  let roll = twistZ * turnProfile;
+  let rolled = rotateZ(curled, sin(roll), cos(roll));
+  let rolledT = rotateZ(curledT, sin(roll), cos(roll));
+  let rolledS = rotateZ(curledS, sin(roll), cos(roll))
+    + twistZ * turnProfileS * vec3f(-rolled.y, rolled.x, 0.0);
+  let sweepPhase = 2.0 * s + time * 0.16;
+  let sweep = deformationStrength * (0.1 + 1.6 * s - 0.7 * s * s + 0.04 * sin(sweepPhase));
+  let sweepS = deformationStrength * (1.6 - 1.4 * s + 0.08 * cos(sweepPhase));
+  let axisScale = vec3f(${nativeParam("scaleX")}, ${nativeParam("scaleY")}, ${nativeParam("scaleZ")});
+  let scaled = (rolled + vec3f(sweep * aspect * size, 0.0, 0.0)) * axisScale;
+  let scaledT = rolledT * axisScale;
+  let scaledS = (rolledS + vec3f(sweepS * aspect * size, 0.0, 0.0)) * axisScale;
+  let rx = ${nativeParam("rotationX")};
+  let ry = ${nativeParam("rotationY")};
+  let rz = ${nativeParam("rotationZ")};
+  let world = rotateZ(rotateY(rotateX(scaled, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz))
+    + vec3f(2.0 * aspect * ${nativeParam("positionX")}, -2.0 * ${nativeParam("positionY")}, 2.0 * ${nativeParam("positionZ")});
+  let tangentT = rotateZ(rotateY(rotateX(scaledT, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz));
+  let tangentS = rotateZ(rotateY(rotateX(scaledS, sin(rx), cos(rx)), sin(ry), cos(ry)), sin(rz), cos(rz));
+  let surface = cross(tangentT, tangentS);
+  let camera = 10.0 + 9.0 * max(aspect, 1.0);
+  let viewDepth = camera - world.z;
+  let nearPlane = 0.1;
+  let farPlane = camera * 2.5;
+  var output: VertexOutput;
+  output.position = vec4f(
+    world.x * camera / aspect,
+    world.y * camera,
+    farPlane / (farPlane - nearPlane) * viewDepth - farPlane * nearPlane / (farPlane - nearPlane),
+    viewDepth
+  );
+  output.uv = uv;
+  output.normal = surface / max(length(surface), 1e-12);
+  output.seam = t;
+  let hue = ${nativeParam("hueShift")};
+  output.hueRotation = vec2f(cos(hue), sin(hue));
+  return output;
+}
+@fragment fn fs(input: VertexOutput) -> @location(0) vec4f {
+  let paint = foldedFill(input.uv, globals.viewport.xy);
+  let oriented = select(input.normal, -input.normal, input.normal.z < 0.0);
+  let normal = oriented / max(length(oriented), 1e-12);
+  let light = normalize(vec3f(-0.36, 0.55, 0.75));
+  let diffuse = max(dot(normal, light), 0.0);
+  let reflection = pow(diffuse, 20.0);
+  let sourceColor = paint.rgb / max(paint.a, 1e-5);
+  let hueAxis = vec3f(0.577350269);
+  let shiftedColor = sourceColor * input.hueRotation.x
+    + cross(hueAxis, sourceColor) * input.hueRotation.y
+    + hueAxis * dot(hueAxis, sourceColor) * (1.0 - input.hueRotation.x);
+  let luma = dot(shiftedColor, vec3f(0.2126, 0.7152, 0.0722));
+  let saturated = mix(vec3f(luma), shiftedColor, ${nativeParam("saturation")});
+  let color = clamp((saturated - vec3f(0.5)) * ${nativeParam("contrast")} + vec3f(0.5), vec3f(0.0), vec3f(1.0));
+  let lineDensity = ${nativeParam("lineDensity")};
+  let fiberPhase = 6.2831853 * lineDensity * input.uv.x + input.uv.y * 34.0
+    + 7.0 * sin(input.uv.x * 29.0 + input.uv.y * 8.0 + (globals.clock.x + ${nativeParam("timeOffset")}) * 0.12);
+  let fiberAA = 1.0 - smoothstep(1.2, 3.2, fwidth(fiberPhase));
+  let fiberEnvelope = smoothstep(0.02, 0.24, input.uv.x)
+    * (1.0 - smoothstep(0.76, 0.98, input.uv.x));
+  let lineThickness = ${nativeParam("lineThickness")};
+  let lineThreshold = 0.92 - 0.84 * lineThickness;
+  let fiber = smoothstep(lineThreshold, 1.0, 0.5 + 0.5 * sin(fiberPhase))
+    * (0.88 + 0.12 * sin(input.uv.y * 19.0 + input.uv.x * 13.0))
+    * fiberAA * fiberEnvelope * min(lineDensity, 1.0) * smoothstep(0.0, 0.04, lineThickness);
+  let seamWidth = 0.004 + 0.048 * ${nativeParam("glowSpread")};
+  let seam = pow(exp(-input.seam * input.seam / seamWidth), 0.3 + 1.4 * ${nativeParam("glowFocus")});
+  let compression = length(vec2f(dpdx(input.uv.x), dpdy(input.uv.x))) * globals.viewport.x;
+  let turnGlow = smoothstep(1.3, 4.5, compression) * ${nativeParam("compressionResponse")};
+  let illumination = 0.91 + 0.16 * diffuse + 0.12 * fiber;
+  let glow = ${nativeParam("glowAmount")} / 0.45;
+  let rgb = paint.a * color * illumination
+    + paint.a * glow * (vec3f(0.12) * reflection + vec3f(0.08) * seam + vec3f(0.06) * turnGlow);
+  return vec4f(clamp(rgb, vec3f(0.0), vec3f(paint.a)), paint.a);
+}
+`,
+    },
+  ],
+  provenance: {
+    origin: "design-original",
+    note: "Original vertex-deformed folded surface with packed native paint.",
+  },
+};