fix(access-control): seed nothing restricted when the config is unknown

Block creation is one-shot, so the withholding pattern the editor's pickers use
does not transfer: withholding the predicate there meant `prepareBlockState`
seeded the declared `operation`/`model` defaults unchecked, and nothing
revisits a field that already holds a value — so a block added before the
permission config resolved kept a model the group may deny.

Both restricted fields now seed empty until the config is known; the pickers
fill them the moment it resolves. A preset operation is still honoured in that
window: unlike a declared default it is the user's explicit pick, and the
server gates the run.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/workflow.tsx

@@ -896,13 +896,19 @@ const WorkflowContent = React.memo(
         if (extent) blockData.extent = extent
 
         const operationGate = resolveOperationGate(getBlock(type))
-        const seedGate = operationGate
-          ? (subBlockId: string, value: string) => {
-              if (subBlockId === OPERATION_SUBBLOCK_ID) return operationGate(value)
-              if (subBlockId === MODEL_SUBBLOCK_ID) return isModelUsable(value)
-              return true
-            }
-          : undefined
+
+        /**
+         * Creation is one-shot, so an unknown permission config cannot be
+         * answered by waiting the way the editor's pickers do — a value written
+         * here is never revisited. The restricted fields therefore seed empty
+         * until the config resolves, and the pickers fill them the moment it
+         * does. Seeding the declared default instead would persist it unchecked.
+         */
+        const seedGate = (subBlockId: string, value: string) => {
+          if (subBlockId !== OPERATION_SUBBLOCK_ID && subBlockId !== MODEL_SUBBLOCK_ID) return true
+          if (!operationGate) return false
+          return subBlockId === OPERATION_SUBBLOCK_ID ? operationGate(value) : isModelUsable(value)
+        }
 
         const block = prepareBlockState({
           id,
@@ -934,8 +940,9 @@ const WorkflowContent = React.memo(
           /* Search and the connection picker already drop denied operations, so
              this only catches one arriving by another route — a recent pick that
              outlived a permission change. Dropping the key rather than the whole
-             preset leaves the permission-corrected default from
-             `prepareBlockState` in place. */
+             preset leaves whatever `prepareBlockState` seeded in place. Unlike a
+             declared default, a preset is the user's explicit pick, so an
+             unknown config honours it and leaves the server to gate the run. */
           const presetOperation = presetSubBlockValues[OPERATION_SUBBLOCK_ID]
           const presetOperationDenied =
             operationGate && typeof presetOperation === 'string' && !operationGate(presetOperation)

apps/sim/stores/workflows/utils.test.ts

@@ -1126,6 +1126,18 @@ describe('prepareBlockState — permission-group seed veto', () => {
     expect(values.operation).toBe('send')
   })
 
+  it('seeds nothing restricted when the gate answers no for an unknown config', () => {
+    /* Creation is one-shot: the caller vetoes both restricted fields while the
+       permission config is loading, since a value written here is never
+       revisited. Unrestricted fields still seed. */
+    const values = seededValues(
+      (subBlockId) => subBlockId !== 'operation' && subBlockId !== 'model'
+    )
+    expect(values.operation).toBeNull()
+    expect(values.model).toBeNull()
+    expect(values.channel).toBe('#general')
+  })
+
   it('passes the seeded value to the gate, not just the field id', () => {
     const seen: Array<[string, string]> = []
     seededValues((subBlockId, value) => {