UI Fails to Display Correct Values for Expressions Combining posterizeTime(0) and sampleImage()

AE 25.6 released, and no fix for this bug...

Very disappointing @JohnColombo.

This is a crazy bug, that takes a DIFFERENT LOGIC PATH for UI compared to the render engine.

The bug is messing with my marketplace template big time, and not even worth a fix?

I guess Adobe thinks it is too specialized to bother fixing??

Please provide an update for those of us that need this fix...

Hi @Fizzrock,

Thank you for all that additional information! I will make a note in our bug ticket for this issue about the additional symptoms you shared. I don't have an update on any fix at this time, unfortunately.

Cheers,

- John, After Effects Engineering Team  

Hello,

@JohnColombo3491446, I'm following up on this bug report with a new, and significantly more severe, set of findings. The original issue, where the UI fails to display the correct value for properties affected by the `posterizeTime(0)` + `sampleImage()` combination, has a critical downstream effect that goes far beyond a simple visual glitch. It creates a "split-brain" scenario where the After Effects UI and the render engine are operating on two different sets of data.

The core of this new problem is that when a downstream expression uses conditional logic (an `if/else` statement) that references a bug-affected property, the UI and the render engine evaluate the condition differently. The render engine correctly uses the true, calculated value of the property and executes the correct logical path. However, the UI's property display (e.g., the value fields in the timeline, or a layer's transform handles in the composition viewer) evaluates the same condition using the *incorrect* default value it sees, and therefore displays a result based on the *wrong* logical path.

This results in a complete desynchronization between what the user sees in the interface and what is actually happening in the composition. For example, the UI might show a layer's position is `[100, 100]` (from the `else` block of an expression), while the layer itself is correctly rendered at its original position (from the `if` block). This makes it impossible to debug expressions, trust the UI's feedback, or interact with layer controls directly, elevating the bug from a cosmetic issue to a fundamental workflow-breaking problem.

Here is a simplified test case to demonstrate this "split-brain" behavior:

### Steps to Reproduce the UI/Engine Desynchronization

**1. Base Setup:**
 * Create a new 1920x1080 composition.
 * Create a new red Solid layer named `"Source"`.
 * Create a new Text layer named `"Test Layer"`.

**2. Create the Bug-Affected Controls:**

 * On the `"Test Layer"`, add an `Expression Controls > Color Control` effect and name it `"Buggy Color"`. Before adding an expression, set its color to pure black (`#000000`).
 * On the `"Test Layer"`, add an `Expression Controls > Checkbox Control` effect and name it `"Buggy Checkbox"`.

**3. Apply the Expressions:**

 * Apply this expression to the **Color** property of the `"Buggy Color"` effect. This triggers the original UI bug.

posterizeTime(0);
thisComp.layer("Source").sampleImage([100,100], [1,1]);

*Observation:* The color swatch will incorrectly display black.

* Apply this expression to the **Checkbox** property of the `"Buggy Checkbox"` effect.

// This checkbox should be ON (true) because the sampled color is red.
if (effect("Buggy Color")("Color")[0] > .01) {
  1; // True
} else {
  0; // False
}

*Observation:* The checkbox will incorrectly appear to be OFF (unchecked).

**4. Create the "Split-Brain" Position Expression:**

* Apply this expression to the **Position** property of the `"Test Layer"`.

isVisible = effect("Buggy Checkbox")("Checkbox");

if (isVisible == 1) {
  // The RENDER engine will use this path.
  thisProperty; // Use the property's current value (center of the comp)
} else {
  // The UI will use this path.
  [100, 100]; // Top-left corner
}

### **Observed Result:**

* **Render/Preview:** The `"Test Layer"` will correctly appear in the **center of the composition** (its original position).

* **UI Display:** The `Position` property values in the timeline will incorrectly show `[100.0, 100.0]`. The layer's transform handles in the composition viewer will also be incorrectly located at `[100, 100]`.

This proves the render engine is correctly evaluating `if (isVisible == 1)` while the UI is incorrectly evaluating the `else` branch. This desynchronization makes direct manipulation and debugging impossible.

**Note:** At any time, commenting out the `posterizeTime(0);` line in the `"Buggy Color"` expression will cause all UI elements to immediately update and display the correct values, confirming it as the trigger for this entire chain of behavior.

Any updates on this bug @JohnColombo17100380 ?

I have identified more significant downstream consequences of this bug; I will report them here soon.

Please bump up this bug to be a fix priority; it is creating havoc in one of my marketplace templates.

Thanks.

Great, thanks John.

Give a shout if it ends up fixed soon in the beta; it's really messing with the workflow on my current project.

Thanks